What is a tuple fmap in Haskell?

In Haskell, the concept of fmap typically applies to Functors, which are type constructors that can have a function "mapped" over their contents. Tuples, by themselves, are not inherently Functors in the standard Haskell library in a way that fmap would automatically work on them as a whole.

However, you can define how fmap should behave for tuples, usually by focusing on one of the elements within the tuple. The most common approach is to apply fmap to the second element of the tuple (often considered the "result" or "value" in situations where the first element represents some kind of metadata or context).

Here's a breakdown:

1. Standard `fmap` and Functors:

- The standard fmap function in Haskell has the type signature: fmap :: Functor f => (a -> b) -> f a -> f b. This means that given a function from a to b, it can apply it to values inside a Functor f.

- Examples of Functors include Maybe, List ([]), Either, etc.

2. Tuple as a Functor (Custom Definition):

- Because the standard tuples (a, b) aren't instances of Functor, we need a custom instance definition if we want to use fmap directly with a tuple. We might define fmap for tuples such that it only applies to the second element, leaving the first element untouched.

3. Custom `fmap` Implementation for Tuples:

- Here's how you could define a Functor instance for a tuple where only the second element is mapped:

instance Functor ((,) a) where
  fmap f (x, y) = (x, f y)

- This instance declaration says that for any type a, the type constructor (,) a (which represents a tuple where the first element has type a) is a Functor. The implementation of fmap applies the given function f to the second element y, while the first element x remains unchanged.

4. Example Usage:

- With this instance, you can use fmap like this:

main :: IO ()
main = do
  let myTuple = (10, "hello") :: (Int, String)
  let mappedTuple = fmap (++ "!") myTuple
  print mappedTuple -- Output: (10,"hello!")

5. Why only apply to the second element?

- The choice to apply fmap to the second element is conventional in situations where the tuple is used to represent a computation or a value alongside some context, error information, or metadata. For example, the first element could be an error code and the second the result of a function, or the first element could be the state of the system and the second some output.

6. Alternatives:

- You can also create custom functions to modify different parts of the tuple if you want. You can use pattern matching to get the value, change it and create a new tuple. It really depends on your use case.

In summary, while standard Haskell doesn't automatically define fmap for tuples, you can create custom Functor instances to enable fmap to be used with tuples, typically focusing on mapping over the second element. This pattern is common when using tuples to carry additional information alongside a result value.

Learn more about this