Safe List Operations | CodeSignal Learn

Safe List Operations | CodeSignal Learn

Introduction: Working Safely With Lists

Welcome to Unit 3! In our previous lesson, we learned how to group data together using lists . Now that you know how to build a list, the natural next step is learning how to work with it. How do we find out its size, take a slice of its items, or read specific values? When writing code, especially as a beginner, it is very common to run into errors that cause a program to crash. For example, asking a computer for the first item of an empty list is a classic way to crash an application. In this lesson, we are going to focus on performing list operations safely. We will use what are called " total functions " — which simply means these functions are safe to use because they know exactly how to handle every possible input, including empty lists. By the end of this lesson, you will know how to query lists safely and write your own custom function to read from a list without ever risking a crash.

Handy Built-In List Functions

Haskell comes with several built-in tools that are totally safe to use on any list. Let's look at five common ones: length, null, take, drop, and reverse . First, let's define a simple list of integers that we will use for our examples. Haskell values :: [Int] values = [10, 20, 30, 40] Now, let's start building our main program step-by-step. We will begin by checking the list's size and seeing if it is empty. Haskell values :: [Int] values = [10, 20, 30, 40] main :: IO () main = do print (length values) print (null values) Output: text 4 False length counts how many items are in the list. Our list has four numbers, so it prints 4 . null checks if the list is completely empty. Since our list has items in it, it prints False . Next, let's look at how we can slice our list. We can grab a few items from the start, or skip a few items to keep the rest. Haskell values :: [Int] values = [10, 20, 30, 40] main :: IO () main = do print (length values) print (null values) print (take 2 values) print (drop 2 values) Output: text ... [10,20] [30,40] take 2 safely grabs the first two items, giving us [10, 20] . drop 2 safely skips the first two items and keeps the rest, giving us [30, 40] . Even if you asked to take 100 from this short list, the program will not crash. It will just safely give you the four items it has. Finally, we can easily flip the list around using reverse . Haskell values :: [Int] values = [10, 20, 30, 40] main :: IO () main = do print (length values) print (null values) print (take 2 values) print (drop 2 values) print (reverse values) Output: text ... [40,30,20,10] The reverse function flips the order of our list backwards. Like the others, it handles empty lists perfectly well (reversing an empty list simply gives you an empty list back).

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

Pattern Matching For Safe Access

In Lesson 1, you learned how to use Pattern Matching to define functions using top-to-bottom rules. In Lesson 2, you learned about the cons operator (:) used to build lists. Let's combine these concepts to write our own custom function called safeHead . The head of a list is its first item. Our function will take a list of integers and return a Maybe Int . Let's write our first rule. What should happen if the list is empty? Haskell safeHead :: [Int] -> Maybe Int safeHead [] = Nothing If the list is perfectly empty ([]), we simply return Nothing . No crashes! Now, let's add the second rule for when the list has at least one item. Haskell safeHead :: [Int] -> Maybe Int safeHead [] = Nothing safeHead (x:_) = Just x Here, we use (x:_) to match the list's shape. x stands for the first item. The : is the cons operator connecting the first item to the rest of the list. The wildcard (_) is the wildcard we learned about in Lesson 1, which means "ignore everything else." If this rule fires, we successfully wrap our first item in our safe box, returning Just x . Let's test our new safe function inside our main program: Haskell values :: [Int] values = [10, 20, 30, 40] safeHead :: [Int] -> Maybe Int safeHead [] = Nothing safeHead (x:_) = Just x main :: IO () main = do print (safeHead values) print (safeHead []) Output: text Just 10 Nothing When we passed our values list, it matched the second rule and safely gave us Just 10 . When we passed an empty list [], it matched the first rule and safely gave us Nothing .

Summary And Practice Prep

Let's look at our complete program that combines all the built-in functions along with our custom safe access function. Haskell values :: [Int] values = [10, 20, 30, 40] safeHead :: [Int] -> Maybe Int safeHead [] = Nothing safeHead (x:_) = Just x main :: IO () main = do print (length values) print (null values) print (take 2 values) print (drop 2 values) print (reverse values) print (safeHead values) print (safeHead []) Output: text 4 False [10,20] [30,40] [40,30,20,10] Just 10 Nothing By relying on total functions and the Maybe type, we have created a robust, crash-proof script. Instead of fearing an empty list, we treat the absence of an element as a perfectly ordinary result that our program can handle. You are making great progress through the course, and you are almost halfway through! As we wrap up the lesson for Unit 3, you are now ready to jump into the CodeSignal IDE. In the upcoming exercises, you will practice querying lists, taking safe slices, and writing your very own pattern-matching functions to handle empty data gracefully.