The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Algebraic Data Types

Next ►
►

Algebraic Data Types (ADTs) are a fundamental concept in Haskell and many other functional programming languages. They allow you to define complex data structures in a very expressive and type-safe manner. In this section, we will cover the basics of ADTs, including their definition, usage, and practical examples.

What are Algebraic Data Types?

Algebraic Data Types are types formed by combining other types. There are two main kinds of ADTs in Haskell:

  1. Sum Types: Also known as tagged unions or variant types, these allow a value to be one of several different types.
  2. Product Types: These combine multiple values into a single type.

Defining Algebraic Data Types

Sum Types

Sum types are defined using the data keyword followed by the type name and its constructors. Each constructor can have zero or more arguments.

data Shape = Circle Float
           | Rectangle Float Float
           | Square Float

In this example:

  • Shape is a sum type.
  • Circle, Rectangle, and Square are constructors.
  • Circle takes one Float argument, Rectangle takes two Float arguments, and Square takes one Float argument.

Product Types

Product types are also defined using the data keyword but typically involve a single constructor with multiple fields.

data Point = Point Float Float

In this example:

  • Point is a product type.
  • The constructor Point takes two Float arguments.

Practical Examples

Example 1: Defining and Using a Sum Type

Let's define a simple sum type to represent a traffic light.

data TrafficLight = Red | Yellow | Green

-- Function to describe the traffic light
describeLight :: TrafficLight -> String
describeLight Red    = "Stop"
describeLight Yellow = "Caution"
describeLight Green  = "Go"

Example 2: Defining and Using a Product Type

Let's define a product type to represent a 2D point and a function to calculate the distance between two points.

data Point = Point Float Float

-- Function to calculate the distance between two points
distance :: Point -> Point -> Float
distance (Point x1 y1) (Point x2 y2) = sqrt ((x2 - x1)^2 + (y2 - y1)^2)

Pattern Matching with ADTs

Pattern matching is a powerful feature in Haskell that allows you to deconstruct ADTs and work with their components.

Example: Pattern Matching with a Sum Type

data Shape = Circle Float
           | Rectangle Float Float
           | Square Float

area :: Shape -> Float
area (Circle r)        = pi * r^2
area (Rectangle w h)   = w * h
area (Square s)        = s^2

Example: Pattern Matching with a Product Type

data Point = Point Float Float

quadrant :: Point -> String
quadrant (Point x y)
  | x > 0 && y > 0 = "First Quadrant"
  | x < 0 && y > 0 = "Second Quadrant"
  | x < 0 && y < 0 = "Third Quadrant"
  | x > 0 && y < 0 = "Fourth Quadrant"
  | otherwise      = "On an axis"

Exercises

Exercise 1: Define a Sum Type

Define a sum type Weather with constructors Sunny, Rainy, Cloudy, and Windy. Write a function weatherDescription that takes a Weather value and returns a description of the weather.

data Weather = Sunny | Rainy | Cloudy | Windy

weatherDescription :: Weather -> String
weatherDescription Sunny  = "It's a bright and sunny day!"
weatherDescription Rainy  = "It's raining. Don't forget your umbrella!"
weatherDescription Cloudy = "It's cloudy but dry."
weatherDescription Windy  = "It's windy. Hold onto your hat!"

Exercise 2: Define a Product Type

Define a product type Person with fields for name, age, and height. Write a function describePerson that takes a Person value and returns a string describing the person.

data Person = Person String Int Float

describePerson :: Person -> String
describePerson (Person name age height) =
  name ++ " is " ++ show age ++ " years old and " ++ show height ++ " meters tall."

Common Mistakes and Tips

  • Forgetting to export constructors: When defining ADTs in a module, remember to export the constructors if you want them to be accessible from other modules.
  • Pattern matching completeness: Ensure that all possible constructors are handled in pattern matching to avoid runtime errors.
  • Using record syntax: For product types with many fields, consider using record syntax for better readability and convenience.

Conclusion

In this section, we covered the basics of Algebraic Data Types in Haskell, including their definition, usage, and practical examples. We also explored pattern matching with ADTs and provided exercises to reinforce the concepts. Understanding ADTs is crucial for writing expressive and type-safe Haskell code. In the next module, we will delve into more advanced topics in Haskell's type system.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved