**Course Title:** Functional Programming with Haskell: From Fundamentals to Advanced Concepts **Section Title:** Type Systems, Type Classes, and Polymorphism **Topic:** Built-in type classes: Eq, Ord, Show, and Enum. **Overview** Type classes in Haskell provide a way to define a set of functions or operations that can be applied to values of a particular type. This allows us to write more generic and reusable code. In this topic, we will explore four built-in type classes: `Eq`, `Ord`, `Show`, and `Enum`. These type classes are commonly used in various applications, and understanding them is crucial for effective Haskell programming. **Eq Type Class** The `Eq` type class is used for types that support equality testing. It provides the `==` and `/=` functions, which are used to check whether two values are equal or not. The `Eq` type class is a subclass of the `Prelude` type class, which means that all types that are instances of `Prelude` can be compared using the `==` and `/=` functions. ```haskell class Eq a where (==) :: a -> a -> Bool (/=) :: a -> a -> Bool x /= y = not (x == y) x == y = not (x /= y) ``` To define an instance of `Eq` for a custom type, you need to provide an implementation for the `==` function. ```haskell data Color = Red | Green | Blue deriving (Eq) instance Eq Color where Red == Red = True Green == Green = True Blue == Blue = True _ == _ = False ``` **Ord Type Class** The `Ord` type class is used for types that support ordering. It provides the following functions: * `compare` : compares two values and returns a value of type `Ordering`, which can be one of `LT`, `EQ`, or `GT`. * `<=` : checks whether a value is less than or equal to another value. * `>=` : checks whether a value is greater than or equal to another value. * `> ` : checks whether a value is greater than another value. * `< ` : checks whether a value is less than another value. ```haskell class Eq a => Ord a where compare :: a -> a -> Ordering (<=) :: a -> a -> Bool (>=) :: a -> a -> Bool (>) :: a -> a -> Bool (<) :: a -> a -> Bool x <= y = compare x y /= GT x >= y = compare x y /= LT x > y = compare x y == GT x < y = compare x y == LT ``` To define an instance of `Ord` for a custom type, you need to provide an implementation for the `compare` function. ```haskell data Color = Red | Green | Blue deriving (Eq, Ord) instance Ord Color where compare Red Red = EQ compare Red _ = LT compare Green Green = EQ compare Green _ = LT compare Blue _ = GT ``` **Show Type Class** The `Show` type class is used for types that can be converted to a string representation. It provides the `show` function, which is used to convert a value to a string. ```haskell class Show a where showsPrec :: Int -> a -> ShowS show :: a -> String show x = showsPrec 0 x "" type ShowS = String -> String ``` To define an instance of `Show` for a custom type, you need to provide an implementation for the `show` function. ```haskell data Color = Red | Green | Blue deriving (Eq, Ord) instance Show Color where show Red = "Red" show Green = "Green" show Blue = "Blue" ``` **Enum Type Class** The `Enum` type class is used for types that have a finite number of values. It provides the `succ` and `pred` functions, which are used to get the next and previous values in the enumeration. ```haskell class Enum a where succ :: a -> a pred :: a -> a toEnum :: Int -> a fromEnum :: a -> Int enumFrom :: a -> [a] enumFromThen :: a -> a -> [a] ``` To define an instance of `Enum` for a custom type, you need to provide an implementation for the `succ`, `pred`, `toEnum`, and `fromEnum` functions. ```haskell data Color = Red | Green | Blue deriving (Eq, Ord) instance Enum Color where succ Red = Green succ Green = Blue succ Blue = Red pred Red = Blue pred Green = Red pred Blue = Green toEnum 0 = Red toEnum 1 = Green toEnum 2 = Blue fromEnum Red = 0 fromEnum Green = 1 fromEnum Blue = 2 ``` **Conclusion** In this topic, we explored the `Eq`, `Ord`, `Show`, and `Enum` type classes in Haskell. These type classes provide a way to define a set of functions or operations that can be applied to values of a particular type. Understanding these type classes is crucial for effective Haskell programming, and they are widely used in various applications. By providing implementations for these type classes, you can write more generic and reusable code. **Practical Exercise:** 1. Define an instance of `Eq` for a custom type `Person` with fields `name` and `age`. 2. Define an instance of `Ord` for the `Person` type. 3. Define an instance of `Show` for the `Person` type. 4. Define an instance of `Enum` for an enumeration type `Day` with values `Monday`, `Tuesday`, `Wednesday`, `Thursday`, `Friday`, `Saturday`, and `Sunday`. **Additional Resources:** * [Haskell Type Classes Documentation](https://hackage.haskell.org/package/base-4.16.0.0/docs/Prelude.html#g:12) * [Haskell Enum Type Class Documentation](https://hackage.haskell.org/package/base-4.16.0.0/docs/Prelude.html#t:Enum) **Leave a comment or ask for help:** If you have any questions or need further clarification on any of the topics covered in this chapter, please leave a comment below. We'll be happy to help. **What's Next?** In the next topic, we will explore algebraic data types and pattern matching in Haskell. We will learn how to define and use algebraic data types to create more complex data structures and how to use pattern matching to control the flow of our programs.