Defining Pure Functions | CodeSignal Learn

Defining Pure Functions | CodeSignal Learn

Introduction to Pure Functions

Welcome back! In our previous units, you learned how to write your first Haskell program using main and explored core data types like Int and Double . Now that you know how to represent basic values, it is time to build your own tools to work with them. In this lesson, we will learn how to write our own custom functions . In Haskell, we write what are called pure functions . You can think of a pure function as a simple vending machine. If you put in a specific code for a snack, you will always get the exact same snack. A pure function works the same way: if you give it the same inputs, it will always give you the same output. There are no hidden surprises, no unexpected changes to other parts of your program, and no side effects. This makes Haskell code very predictable and easy to trust.

Writing Single-Argument Functions

Before a function can perform calculations, we have to tell Haskell what type of data the function uses. We do this using a type signature . A type signature acts as a blueprint. Let's create a simple function called double that takes a whole number and multiplies it by two. First, we write the type signature using an arrow (->): Haskell double :: Int -> Int In this signature, double is the name of our function. The :: symbol means "has the type of." The arrow (->) separates the input from the output. The last type in the line is always the output. Everything before it is an input. So, Int -> Int means this function takes one integer as an input and returns one integer as an output. Next, we write the actual logic on the very next line: Haskell double :: Int -> Int double n = n * 2 Here, double n means our function takes a value and calls it n . The equals sign (=) starts the definition. Finally, n * 2 is the math that produces our output. Because a single file can hold many different functions, let's add a second tool. We will create a square function that multiplies a number by itself. Haskell double :: Int -> Int double n = n * 2 square :: Int -> Int square n = n * n Notice that square has the exact same type signature shape (Int -> Int) as double . This shows us that the type signature defines the shape of the data, but the internal mathematical logic is completely up to you!

Writing Multi-Argument Functions

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Often, a function needs more than one piece of information to do its job. For example, finding the average of two numbers requires two separate inputs. Let's write an average function. Since an average often results in a decimal, we will remind ourselves of the Double type from our last unit. Here is how we write a signature with multiple inputs: Haskell average :: Double -> Double -> Double How do we read multiple arrows? Remember, the very last type is always the single output. Every type before that is an input. It can help to picture the signature labeled like this: text average :: Double -> Double -> Double -- input 1 input 2 result This signature means the function takes a first Double, a second Double, and finally returns a Double as the result. Now we can write the equation: Haskell average :: Double -> Double -> Double average a b = (a + b) / 2 We list our input names a and b right after the function name. These match up perfectly with the first two Double types in our signature. We put (a + b) inside parentheses so they are added together first, and then we divide by 2 .

Calling Functions in main

We have our blueprints and our math logic ready. Now, we need to actually use them. As you learned in Unit 1, a Haskell program starts running in the main block. Let's start by using our double function. We will pass it the number 21 and print the result to the screen. Haskell main :: IO () main = do print (double 21) We use parentheses around (double 21) so Haskell knows to calculate that entire function first and then pass the final answer to print . Now, let's put our complete file together. We will place our pure functions at the top and then call all of them inside main . Haskell double :: Int -> Int double n = n * 2 square :: Int -> Int square n = n * n average :: Double -> Double -> Double average a b = (a + b) / 2 main :: IO () main = do print (double 21) print (square 8) print (average 4.0 9.0) When you run this complete program, you will see the following output on your screen: text 4264 6.5 Seeing these outputs proves that our functions work independently. The double function correctly turned 21 into 42 . The square function turned 8 into 64 . And our multi-argument average function safely turned 4.0 and 9.0 into 6.5 .