Tuples – Haskell

In Haskell, tuples are a powerful and versatile way to store and work with multiple values. Unlike lists, which hold elements of the same type, tuples allow you to combine values of different types within a single, fixed-size structure. This makes tuples especially useful for grouping related but distinct pieces of data, like coordinates, database records, or function outputs.

In this article, we’ll explore what tuples are, how to use them effectively, and how they differ from other data structures in Haskell.

What is a Tuple?

A tuple is an ordered collection of elements, where each element can have a different type. Tuples are immutable and have a fixed size, meaning the number of elements in a tuple is locked when it is created and cannot be changed.

A tuple in Haskell is written by enclosing elements in parentheses, separated by commas. For example:

-- A tuple containing an Int and a String
(5, "hello")

-- A tuple containing three values: a Char, an Int, and a Float
('a', 42, 3.14)

In these examples:

• (5, "hello") is a tuple with two elements of types Int and String.
• ('a', 42, 3.14) is a three-element tuple containing a Char, an Int, and a Float.

Key Characteristics of Tuples

1. Fixed Size: Tuples have a fixed number of elements. For instance, a two-element tuple (pair) will always contain exactly two elements.
2. Heterogeneous Types: Unlike lists, tuples can contain elements of different types.
3. Immutable: Once a tuple is created, its values cannot be changed.

Common Types of Tuples

1. Pair (2-tuple): A tuple with two elements.

("John", 25)  -- A tuple with a String and an Int

2. Triple (3-tuple): A tuple with three elements.

("John", 25, True)  -- A tuple with a String, an Int, and a Bool

3. Larger Tuples: Tuples can have more than three elements, although Haskell standard libraries generally don’t provide functions for tuples with more than five elements due to practicality and readability.

("John", 25, True, 4.5, 'A')  -- 5-element tuple

Creating and Accessing Tuples

Tuples can be created directly by writing values inside parentheses, separated by commas:

-- A tuple containing a String, an Int, and a Bool
personInfo :: (String, Int, Bool)
personInfo = ("Alice", 30, True)

To access elements in a tuple, you generally use pattern matching instead of indexing (since tuples do not support direct indexing).

Example of Pattern Matching with a Tuple

-- Function that extracts information from a tuple
showPersonInfo :: (String, Int, Bool) -> String
showPersonInfo (name, age, isEmployed) =
    name ++ " is " ++ show age ++ " years old and employment status is " ++ show isEmployed

In this example, showPersonInfo takes a tuple with three elements: a String, an Int, and a Bool. Pattern matching allows us to assign each element in the tuple to a variable (name, age, isEmployed) and then use those values within the function.

Using Tuples in Functions

Tuples are particularly useful when you need to return multiple values from a function. In Haskell, a function can only return a single value, but that value can be a tuple containing multiple elements.

Example: Returning Multiple Values with a Tuple

calculateStats :: [Int] -> (Int, Int, Float)
calculateStats xs =
    let total = sum xs
        count = length xs
        average = fromIntegral total / fromIntegral count
    in (total, count, average)

Here, calculateStats takes a list of integers and returns a tuple containing:

1. The sum of the list,
2. The count of elements in the list,
3. The average of the list.

This function makes use of a three-element tuple to return all three calculated values at once.

Tuple Functions in Haskell

Haskell provides a few built-in functions for working with pairs (2-tuples). Here are some commonly used ones:

1. fst: Returns the first element of a pair.

fst (10, "Hello")  -- Result: 10

2. snd: Returns the second element of a pair.

snd (10, "Hello")  -- Result: "Hello"

For tuples with more than two elements, there are no built-in functions like fst and snd. Instead, pattern matching is typically used to extract values.

Nested Tuples

Tuples can also contain other tuples as elements, creating nested tuples. While this can be useful, it’s important to use nested tuples thoughtfully, as they can become difficult to read.

Example of a Nested Tuple

-- A tuple containing an Int, a Bool, and another tuple
nestedTuple :: (Int, Bool, (String, Double))
nestedTuple = (42, True, ("Nested", 3.14))

To extract values from a nested tuple, you can use pattern matching as follows:

extractNested :: (Int, Bool, (String, Double)) -> String
extractNested (num, _, (str, _)) = str

Here, extractNested takes a nested tuple and uses pattern matching to extract and return the String from the inner tuple.

Tuples vs. Lists

Tuples and lists may seem similar at first glance, but they serve different purposes:

Aspect	Tuple	List
Size	Fixed	Variable
Element Types	Can differ	Must be the same
Access	Pattern matching	Indexing
Typical Use Case	Grouping different types of data	Collection of homogeneous items

Tuples are best suited for grouping related but diverse data (e.g., a record of a person’s name, age, and employment status), while lists are ideal for collections of the same type (e.g., a list of integers or strings).

Practical Examples of Tuples in Haskell

Example 1: Storing Coordinates

Tuples are commonly used for storing coordinates in 2D or 3D space.

type Point2D = (Double, Double)
type Point3D = (Double, Double, Double)

distance :: Point2D -> Point2D -> Double
distance (x1, y1) (x2, y2) = sqrt ((x2 - x1) ^ 2 + (y2 - y1) ^ 2)

Example 2: Pairing Related Data

Tuples can pair related data, such as a person’s name and their age.

people :: [(String, Int)]
people = [("Alice", 30), ("Bob", 25), ("Carol", 40)]

Example 3: Returning Multiple Results

When performing multiple calculations within a function, tuples provide an easy way to return several results.

minMax :: [Int] -> (Int, Int)
minMax xs = (minimum xs, maximum xs)

-- Usage
minMax [3, 5, 2, 8, 1]  -- Result: (1, 8)

Conclusion

Tuples in Haskell are a flexible and convenient way to group values of different types. They are particularly useful for returning multiple values from functions, handling related data with diverse types, and creating simple structures without defining new data types. While tuples are a versatile tool in Haskell, using them thoughtfully (especially nested tuples) will keep your code clean and readable. Whether for coordinates, multi-value returns, or structured data, tuples play an important role in Haskell programming.