Pure Function

5 Key excerpts on "Pure Function"

• 

  eBook - ePub

  Mastering JavaScript Functional Programming

  Write clean, robust, and maintainable web and server code using functional JavaScript, 2nd Edition

  • Federico Kereki(Author)
  • 2020(Publication Date)
  • Packt Publishing

    (Publisher)

  Behaving Properly - Pure Functions

  In Chapter 3 , Starting Out with Functions – A Core Concept , we considered functions as the key elements in Functional Programming (FP ), went into detail about arrow functions, and introduced some concepts, such as injection, callbacks, polyfilling, and stubbing. In this chapter, we'll have the opportunity to revisit or apply some of those ideas. We will also do the following:

  • Consider the notion of purity , and why we should care about Pure Functions —and impure functions as well!
  • Examine the concept of referential transparency .
  • Recognize the problems implied by side effects.
  • Show some advantages of Pure Functions.
  • Describe the main reasons behind imPure Functions.
  • Find ways to minimize the number of imPure Functions.
  • Focus on ways of testing both pure and imPure Functions.

  Passage contains an image

  Pure Functions

  Pure Functions behave in the same way as mathematical functions and provide diverse benefits. A function is pure if it satisfies two conditions:

  • Given the same arguments, the function always calculates and returns the same result : This should be true no matter how many times it's invoked or under which conditions you call it. This result cannot depend on any outside  information or state, which could change during the program execution and cause it to return a different value. Nor can the function result depend on I/O results, random numbers, some other external variable, or a value that is not directly controllable.

  • When calculating its result, the function doesn't cause any observable side effects
    : This includes output to I/O devices, the mutation of objects, changes to a program's state outside of the function, and so on.

  If you want, you can simply say that Pure Functions don't depend on (and don't modify) anything outside their scope and always return the same result for the same input arguments.

  Another word used in this context is idempotency

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  The JavaScript Workshop

  A New, Interactive Approach to Learning JavaScript

  • Joseph Labrecque, Jahred Love, Daniel Rosenbaum, Nick Turner, Gaurav Mehla, Alonzo L. Hosford, Florian Sloot, Philip Kirkbride(Authors)
  • 2019(Publication Date)
  • Packt Publishing

    (Publisher)

  These concepts will be covered over the course of this chapter. If implemented correctly, functional programming can result in code that is more predictable, less error-prone, and easier to test compared to other programming methods.

  Pure Functions

  Pure Functions are one of the pillars of functional programming. A function is pure if it always returns the same result when it's given the same parameters. It also cannot depend on or modify variables or state outside of the function's scope.

  A simple example of an imPure Function is as follows: var positionX = 10; function moveRight(numSlots) { return positionX += numSlots; } moveRight(5);

  You can plainly see how the function is manipulating a value outside of its scope in the positionX global variable. A Pure Function should only use the arguments that have been passed in for its logic, and should not directly modify them. Another issue is that the function doesn't actually return a value.

  Consider the following code. Can you see why it would not be considered a pure function? var positionX = 10; function moveRight(numSlots) {     return positionX + numSlots; } positionX = moveRight(5);

  Though the function only reads the global variable value and does not manipulate the variable directly, it is still not pure. To see why think about what happens if you call the function multiple times with the value 5 for the numSlots parameter:

  • The first time, the result is 15 (since positionX is 10 and 10 + 5 = 15 )
  • The second time, the result would be 20
  • The third time, the result would be 25

  In other words, there is a different result for each invocation. For the function to be pure, the result would have had to resolve to the exact same value for the given parameter value, that is, 5

  Sign up to read

  Learn more about book
• 

  eBook - ePub

  Functional Programming in C#, Second Edition

  • Enrico Buonanno(Author)
  • 2022(Publication Date)
  • Manning

    (Publisher)

  Mutates global state—Global here means any state that’s visible outside of the function’s scope. For example, a private instance field is considered global because it’s visible from all methods within the class.
• Mutates its input arguments—Arguments passed by the caller are effectively a state that a function shares with its caller. If a function mutates one of its arguments, that’s a side effect that’s visible to the caller.
• Throws exceptions—You can reason about Pure Functions in isolation; however, if a function throws exceptions, then the outcome of calling it is context-dependent. Namely, it differs depending on whether the function is called in a try -catch .
• Performs any I/O operation—This includes any interaction between the program and the external world, including reading from or writing to the console, the filesystem, or a database, and interacting with any process outside the application’s boundary.
In summary, Pure Functions have no side effects, and their output is solely determined by their inputs. Note that both conditions must hold:
• A function that has no side effects can still be impure. Namely, a function that reads from global mutable state is likely to have an output that depends on factors other than its inputs.
• A function whose output depends entirely on its inputs can also be impure. It could still have side effects such as updating global mutable state.
The deterministic nature of Pure Functions (they always return the same output for the same input) has some interesting consequences. Pure Functions are easy to test and to reason about.1
Furthermore, the fact that outputs only depend on inputs means that the order of evaluation isn’t important. Whether you evaluate the result of a function now or later, the result does not change. This means that the parts of your program that consist entirely of Pure Functions can be optimized in a number of ways: