Defining Custom Data Types | CodeSignal Learn

Defining Custom Data Types | CodeSignal Learn

Introduction: Beyond Type Synonyms

Welcome to the second unit of our course! In our previous lesson, you learned how to use the type keyword to create type synonyms . As a quick reminder, we used statements like type Title = String to give new, descriptive names to existing data types. This helped make our code much easier to read. However, type synonyms only rename things that already exist. Today, we are taking a big step forward. We are going to learn how to build our own completely new data models from scratch using the data keyword. By the end of this lesson, you will be able to define custom types to perfectly fit the needs of your programs.

Creating Simple Choices: The data Keyword

Let's start by looking at how to define a custom type that represents a simple choice. Imagine that we want to track whether a task is unfinished or finished. We can create a brand-new type called Status . Haskell data Status = Todo | Done In this code, data is the keyword telling Haskell that we are creating a new type. Status is the name of our new type. On the right side of the equal sign, we have Todo | Done . Todo and Done are called constructors . You can think of constructors as the specific, named values that our new type is allowed to be. The vertical bar | simply means "or." So, a Status can be either Todo or Done . However, there is a catch. By default, Haskell does not automatically know how to print custom types to the screen, and it does not automatically know how to check if two custom values are equal. If we try to write print Todo right now, the program will fail to compile because Haskell cannot find a Show Status instance. To fix this in a simple beginner-friendly way, we can ask Haskell to create these standard instances for us by adding a small piece of code to the end of our definition: Haskell data Status = Todo | Done deriving (Show, Eq) Adding deriving (Show, Eq) automatically creates two useful instances for our custom type: Show teaches Haskell how to convert our type into text so that it can be printed to the screen. Eq (short for equality) teaches Haskell how to compare two values using the == symbol to see if they are the same. A Show instance is required for print, and an Eq instance is required for == . In more advanced Haskell, programmers can write these instances by hand, but in this course we will use deriving (Show, Eq) as the simplest way to create them.

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

Bundling Information: Building the Task Type

Now that we know how to make a simple choice, let's look at how to bundle multiple pieces of information together into a single package. First, let's bring back the type synonyms we learned in the previous lesson so that our code is easy to read: Haskell type TaskId = Int type Title = String Now, we want to create a Task type that contains an ID, a title, and a status. Here is how we define it: Haskell data Task = Task TaskId Title Status deriving (Show, Eq) This might look a little confusing at first because the word Task appears twice. This is a very common pattern in Haskell : The first Task (before the equal sign) is the name of the Type . The second Task (after the equal sign) is the Constructor . In this case, the constructor acts like a container. It expects three pieces of information to be packed inside it: a TaskId, a Title, and a Status . And, just like before, we add deriving (Show, Eq) so that Haskell automatically creates the standard instances we need to print and compare our tasks.

Putting It All Together: Creating and Printing Values

Let's see how everything works together. First, we will write a function to describe a task as a simple string, just like we did in the past. Haskell describeTask :: TaskId -> Title -> String describeTask tid title = "#" ++ show tid ++ " " ++ title Next, let's create a concrete value using our new Task type. We do this by writing our constructor name followed by the data it needs. Haskell sampleTask :: Task sampleTask = Task 1 "Write report" Todo Here, we used the Task constructor to glue together the ID 1, the title "Write report", and the status Todo . Finally, let's write our main function to test everything out. We will print our custom task, check if it is equal to itself, and print a basic description. Haskell main :: IO () main = do print sampleTask print (sampleTask == sampleTask) putStrLn (describeTask 2 "Review code") When we run this complete program, the output will look like this: Task 1 "Write report" Todo True #2 Review code print sampleTask outputs exactly what we typed: Task 1 "Write report" Todo . This is possible because we added deriving (Show) to our Task type, which created the needed Show instance. print (sampleTask == sampleTask) evaluates to True . This works smoothly because we added deriving (Eq), which created the needed Eq instance. putStrLn (describeTask 2 "Review code") works just as it always has, proving that our custom types can live comfortably alongside normal functions.