Polymorphism – Haskell

Polymorphism, in programming, allows functions and data types to operate in a generalized way, enabling flexibility and reusability in code. Haskell, a purely functional language, provides powerful forms of polymorphism that enable functions to handle various types and allow developers to write concise, elegant code.

This article will delve into the types of polymorphism in Haskell, why they’re useful, and how they work.

What is Polymorphism?

Polymorphism, at its core, means “many shapes.” In Haskell, it enables functions and types to operate on different data types without being rewritten for each type. This ability makes polymorphic code more general, expressive, and often easier to maintain.

There are two primary types of polymorphism in Haskell:

1. Parametric Polymorphism
2. Ad-hoc Polymorphism

Let’s explore each type in detail.

1. Parametric Polymorphism

Parametric polymorphism allows functions to operate on any data type. It’s known as “parametric” because the function is written without specifying concrete types, letting it work across multiple types. This flexibility means that, for example, a single function could work with both lists of integers and lists of strings.

In Haskell, parametric polymorphism is often achieved with type variables. Type variables allow functions to take arguments of any type, making them more versatile.

Example of Parametric Polymorphism

Consider the function identity, which returns whatever argument it is given:

identity :: a -> a
identity x = x

Here, a is a type variable, meaning it can represent any type. The identity function works for any type, whether Int, String, Bool, or a custom type. Haskell infers the type based on the argument it receives:

identity 5          -- Result: 5 (Int)
identity "Haskell"  -- Result: "Haskell" (String)
identity True       -- Result: True (Bool)

The function is truly generic, as it applies the same logic regardless of the type it operates on. Parametric polymorphism ensures the function behaves uniformly across types.

Benefits of Parametric Polymorphism

• Reusability: Functions can be written once and reused across different types.
• Safety: The compiler enforces that the function doesn’t depend on any particular type, so there’s no risk of unexpected behavior based on types.

2. Ad-hoc Polymorphism (Type Classes)

Ad-hoc polymorphism, or type classes in Haskell, allows for overloading functions based on the type of their arguments. Unlike parametric polymorphism, which treats all types the same, ad-hoc polymorphism enables different implementations for specific types.

Type classes are essentially interfaces defining a set of functions that can operate on a type. Types that want to use those functions must be instances of the type class, implementing its required functions.

Example of Ad-hoc Polymorphism: The Eq Type Class

The Eq type class provides an interface for equality comparison. Any type that wants to support equality checks must implement the Eq type class.

class Eq a where
  (==) :: a -> a -> Bool
  (/=) :: a -> a -> Bool

By defining (==) and (/=), the Eq type class allows types like Int and Char to support equality comparisons:

5 == 5        -- Result: True (Int instance of Eq)
'a' == 'a'    -- Result: True (Char instance of Eq)
"Hello" /= "" -- Result: True (String instance of Eq)

The beauty of ad-hoc polymorphism is that Haskell can apply different implementations of == depending on the type. This flexibility allows for distinct behaviors on a per-type basis.

Creating Custom Instances of Type Classes

If you create a custom data type, you can make it an instance of Eq by defining == and /= for it. Here’s an example with a Person type:

data Person = Person { name :: String, age :: Int }

instance Eq Person where
  (Person name1 age1) == (Person name2 age2) = name1 == name2 && age1 == age2

With this instance, two Person values are considered equal if they have the same name and age.

Other Common Type Classes in Haskell

Haskell has many built-in type classes, including:

• Ord: Allows comparison operations (<, >, <=, >=).
• Show: Allows types to be converted to strings, used for printing.
• Read: Allows parsing strings into types.

By leveraging type classes, Haskell lets you define common functionality that’s specific to certain types, enhancing flexibility and readability.

Combining Parametric and Ad-hoc Polymorphism

Haskell often combines parametric and ad-hoc polymorphism to write even more powerful and generalized functions. For instance, consider a function compareValues that works only with types that are both Eq and Ord:

compareValues :: (Eq a, Ord a) => a -> a -> String
compareValues x y
  | x == y    = "Equal"
  | x < y     = "Less than"
  | otherwise = "Greater than"

The type signature (Eq a, Ord a) => a -> a -> String means that compareValues can work with any type that implements both the Eq and Ord type classes. Here, parametric polymorphism makes the function general, while ad-hoc polymorphism ensures it works only with types that support comparison and equality.

Why Use Polymorphism in Haskell?

Polymorphism is a cornerstone of Haskell’s flexibility and expressiveness. It enables Haskell developers to write code that’s:

• Generalized: Functions are adaptable and not limited to specific data types.
• Reusable: By using type variables and type classes, Haskell allows you to create functions that work across diverse types without rewriting code.
• Safe and Reliable: Haskell’s type system ensures that polymorphic functions are type-safe, catching potential issues at compile-time.

Conclusion

Polymorphism in Haskell empowers developers to create flexible, reusable, and type-safe code. Parametric polymorphism allows functions to be written generically, while ad-hoc polymorphism enables specific implementations for different types via type classes. This dual approach not only promotes code reusability but also aligns well with Haskell’s focus on safety and functional purity. Understanding and applying polymorphism can unlock new levels of expressiveness in your Haskell programs, making your code both robust and elegant.