Question

If I had data and I wasn’t sure if this was an Integer or a String, but I wanted to apply (+1) to it, if its an integer great, but if its a String- do nothing, how would I handle this? Is this where Nothing comes in?

Answer 1

Well, Haskell functions are strongly typed, which means they specify the types of their inputs and outputs. In order to even accept a value of multiple types in the first place, you need to use Either to hold them within the same type. So, for example, if you want to receive either a String or an Integer, then your function must have type:

f :: Either String Integer -> ...

Then, the way you write your function is to pattern match on the Either to see which type of value you received. You would write something like:

-- str is a String
f (Left  str) -> ... 
-- int is an Integer
f (Right int) -> ...

So, the easiest way to do what you want is to only increment the number if it is an Integer, but leave the String untouched. You would write it like this:

-- Don't do anything if it is a string
f (Left  str) = Left  str
-- Increment it if it is an integer
f (Right int) = Right (int + 1)

If you ask the compiler to infer the type of the above function, you will get:

f :: Either String Int -> Either String Int

Haskell has a nice trick to avoid the above boilerplate, which is to use fmap from the Functor class. This lets us automatically write functions on just the Right half of the Either while completely ignoring whatever is in the Left half, like so:

f = fmap (+1)

If we infer the type of the above function, it actually comes out to:

f :: (Functor f, Num a) => f a -> f a

But in our case we can specialize the type by setting a to Integer and f to Either String:

f :: Either String Int -> Either String Int

In other words, Either String is one example of an instance of the Functor class, of which there are many.

However, note that in order to use this function on integers or strings, you must first wrap them in Left or Right constructors. For example, these will not type-check:

f 1   -- WRONG!
f "a" -- WRONG!

But these will:

f (Right  1) -- Correct!
f (Left "a") -- Correct!

This means that if you had, say, a list of integers an strings, you would have to write it something like:

list = [Right 1, Left "a", Right 2]

Notice that if you try to mix integers and strings within a list, you get a type error:

list = [1, "a", 2] -- WRONG!

Then we could map f over the first correct list to get:

map f list = [Right 2, Left "a", Right 3]