**Course Title:** Functional Programming with Haskell: From Fundamentals to Advanced Concepts **Section Title:** Type Systems, Type Classes, and Polymorphism **Topic:** Create custom type class instances and use Haskell’s type inference in real-world functions. In this lab topic, we will explore how to create custom type class instances and effectively utilize Haskell's type inference feature in real-world functions. Understanding type classes and polymorphism is crucial for writing flexible and reusable code in Haskell. ### Understanding Type Class Instances A type class instance is a way of making a specific type conform to a type class. This is achieved by providing implementations for the type class's members (functions) that work with the specific type. When we define a type class instance, we are essentially stating that the type supports a specific set of operations. ### Creating a Custom Type Class Before creating custom type class instances, let's define a simple type class. Here's an example: ```haskell -- MyClass.hs class MyClass a where myFunc :: a -> String ``` This defines a type class `MyClass` with a single member function `myFunc` that takes a value of type `a` and returns a string. ### Creating Custom Type Class Instances To create a custom type class instance, we need to define an instance of the type class for a specific type. Let's create an instance of `MyClass` for the `String` type: ```haskell -- MyClass.hs instance MyClass String where myFunc s = "Hello, " ++ s ``` This defines an instance of `MyClass` for the `String` type. The `myFunc` function takes a string and returns a new string by prepending "Hello, ". ### Creating Custom Type Class Instances for Records Let's say we have a record type `Person` and we want to create a custom type class instance for it: ```haskell -- Person.hs data Person = Person { name :: String, age :: Int } instance MyClass Person where myFunc person = "Hello, " ++ name person ``` This defines an instance of `MyClass` for the `Person` record type. The `myFunc` function takes a `Person` record and returns a string greeting. ### Using Type Inference Haskell's type inference feature allows us to write code without explicit type annotations. The type checker will infer the types of variables, expressions, and functions. Here's an example of a real-world function that uses type inference: ```haskell -- util.hs double :: Num a => a -> a double x = x * 2 applyTwice :: (a -> a) -> a -> a applyTwice f x = f (f x) ``` In this example, the `double` function is polymorphic, meaning it can work with any type that supports the `Num` type class. The `applyTwice` function takes a function `f` and a value `x` and applies `f` twice to `x`. Both functions use type inference to determine the types. ### Using Type Inference in Real-World Functions Let's say we have a function that takes a list of numbers and returns the sum of squares: ```haskell -- math.hs sumOfSquares :: [Double] -> Double sumOfSquares numbers = sum [x * x | x <- numbers] ``` This function uses type inference to determine the types. The type checker will infer that the `numbers` variable has type `[Double]`. However, we can make this function more polymorphic by using type inference: ```haskell -- math.hs sumOfSquares :: Num a => [a] -> a sumOfSquares numbers = sum [x * x | x <- numbers] ``` Now the function will work with any type that supports the `Num` type class. ### Conclusion In this lab topic, we learned how to create custom type class instances and effectively utilize Haskell's type inference feature in real-world functions. We saw how to define custom type classes, create instances for specific types, and use type inference to write more polymorphic code. Key Takeaways: * **Define custom type classes**: To create custom type classes, use the `class` keyword followed by the type class name and type variables. * **Create custom type class instances**: To create custom type class instances, use the `instance` keyword followed by the type class name and type. * **Use type inference**: Haskell's type inference feature allows us to write code without explicit type annotations. * **Write polymorphic code**: Use type inference and type classes to write more polymorphic code that can work with different types. External Resources: * [Haskell Type Classes Documentation](https://hackage.haskell.org/package/base-4.16.0.0/docs/Control.Monad.html#t:Monad) * [Haskell Type Inference Documentation](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/type-inference.html#type-inference) Leave a comment below if you have any questions or need help with the material. No further discussion is required for this topic. In the next topic, we will learn how to define custom data types using algebraic data types.