Please Buy now at Leanpub
Written and illustrated by GetContented.
Published on 2016-12-19.
One of the simplest types possible has only two values. They represent truth and falsehood. In Haskell, this type is called
Bool (short for boolean), and its two values are named
True :: Bool False :: Bool
In later chapters, we’ll see how important these two values are. We’ll use them for checking things, and doing all sorts of other useful things. For now, we’re going to use them to introduce you to how to really think about functions.
Let’s imagine you’re a book-seller on holidays looking for a good spot to read a pocket book called “The magic language of Haskell”, and you end up in a milk bar on planet Boolean where the local currency is
Bool coins. You just bought a milkshake, and now you really want to play your favourite song on the jukebox as you read, so you open up your money holder, and here’s what you see:
False coins. The jukebox takes two
True coins, and you only have one of them.
You spy a misshapen robot character at one end of the bar who might be a Haskell wizard. Maybe this guy can help.
He puts down his milkshake, and as you explain your plight to him, he stops frowning and clicking his tongue and reaches into his cloak. Pushing a small glowing bag in your direction, he seems genuinely happy to be able to help.
“You pay for these by learning how they work” he says simply, refusing your offer of paying with False coins. Satisfied, you take the bag and look inside as you walk to the jukebox. You pick out one of the glowing coins inside, and take a look. It appears to be made of something magical:
You notice an inscription on the coin. It looks like some kind of arcane magical writing, obviously written in Haskell, the ancient magical language of the robot wizard folk:
(\x -> True) :: Bool -> Bool
You’re a little familiar with this language yourself. Being a book-seller, you like to read many of the titles you stock, some of them about Haskell. Happily you remember you just happen to have that beginner’s pocket guide to the Haskell language in your back pocket. Oh yes, that was why you came in here in the first place, to read it!
You recall that the arrow symbol
(->) usually indicates a function: that is, a mapping from one type of things to another type. However, here there is a
True value on the right, and
\x on the left. These aren’t types. What’s going on?
You consult your pocket book, and after a few minutes of rifling through the pages, you discover that this is a thing called a lambda, in coin form. A lambda, you read, is a function with no name: a way of getting a completely new value from a value. It also says functions are values, too, but you don’t know what that could possibly mean, so you ignore that for now.
The syntax, (that is, the way it’s written), has
\ followed by a variable name that represents what you are applying this function to. This variable can be used in the area to the right of
(->). It seems this lambda isn’t using the
(x) variable name it has at all. This lambda produces a new
True whenever you apply it to any
False value and ignores the
x variable entirely.
This is great! It’s just what you wanted. You can take your
False coins and make new
True ones from them! Those wily robot wizards, making such magic!
You take one of your coins, and you place it to the right of the magic coin, so its magic will bind them together. POP!
The magic coin pops, they both disappear, and a brand new
True coin appears! Slowly you realise you just did something very silly, though.
The coin you applied to the magic coin was that single
True coin you already had! So it did nothing, effectively. You write this down in the margin of your book, for future reference:
(\x -> True) True -- Equals True -- Pointless waste. Don't do this!
-- code is called a comment, and it’s not part of the code, it’s just for marking notes you can write to readers of your code, including yourself. When Haskell sees
--, it will ignore all the writing to the right of it until the end of the line.
You wrote parentheses around the lambda expression. If you didn’t, Haskell would think the first
True was a function, and that you wanted to apply it to the second
True, and that would cause Haskell to not compile your program.
So now you’ve used your single
True coin, but you got another one in its place, so no harm done you suppose to yourself, though you did just use up one of your magic lambda coins.
Time to try with a
False coin. Frrrrzzzzt... POP! Brilliant! It worked. You now have two
True coins so you can play your song. You note your new discovery in your note-book:
(\x -> True) False -- Equals True
Before you play your song though, you get curious. What if you fed one of your magically created coins into another one of those magic coins? Will it explode? Will the world stop?
Furtively, you glance over toward the robot wizard for guidance, but he appears to be engaged in an apparently amusing conversation with himself about folding wizard gowns into luggage and catamorphisms, whatever they are.
Why not try! You quickly grab a magic coin, and thrust one of your newly made coins next to it. POP! again. It does exactly what happened the first time. So you write this down, too:
(\x -> True) ((\x -> True) False) -- equals True
You read that back and it looks a little complicated. The part on the right is the coin that resulted from shoving a
False into the magic coin. Then we put that whole bracketed thing on the right of another magic coin. It’s correct, just has lots of things going on!
You slide over to the juke box, put your coins in and then begin listening to the sweet sounds of Never Gonna Give You Up by Rick Astley, a timeless classic on your home-world.
You go back to your seat and keep reading the book a bit more. You’ve seen definitions before. You know how to make them. We see a definition for a magic coin:
magicCoin :: Bool -> Bool magicCoin = \x -> True
You read on and find out that because we’re not using
x in the body of our function, we can actually replace it with the underscore character; “
_” to say that this is a function that has one argument, but it won’t be used. Fascinating, you think, as you hum happily, sipping your shake.
We leave our story here, but we see that we can use the
magicCoin function in the same way that we used
putStrLn earlier, except because
magicCoin has type
Bool -> Bool, we can feed an applied expression of it into another application of it.
magicCoin :: Bool -> Bool magicCoin = \_ -> True newCoin :: Bool newCoin = magicCoin False newCoinAgain :: Bool newCoinAgain = magicCoin newCoin newCoinAgain' :: Bool newCoinAgain' = magicCoin (magicCoin False)
We can keep applying it as many times as we like, however this
magicCoin function is only useful if you want to take a
False and make a sure it's a
There’s another way to write this function in Haskell. Let’s take a look at it:
magicCoin' :: Bool -> Bool magicCoin' _ = True
We don’t have lambda syntax here. This is regular function definition syntax. We’re using “
_” to pattern-match on any value at all, and not use it.
We could have also written this function like this, listing out one equality definition for each value in the argument:
magicCoin'' :: Bool -> Bool magicCoin'' True = True magicCoin'' False = True
There is no reason to do this with our trivial example, but this shows you another way to write functions. We could write a function that flips a boolean value to its opposite value. This is actually built into Haskell already as the function named
not, but we’ll make our own, and show you how easy it is to read it:
not' :: Bool -> Bool not' True = False not' False = True
This means we first check if the input value is
True, and if so, we return
False. If it's
False, we return
True. This is called pattern matching. It's just simple pattern-matching: matching on the values.
Let’s look at another lambda, but this one will return the
magicCoin function! Let’s really think about this. Functions are values just like
Bool values or
String values or any other type of values. What about the type of this function that returns a function? It will take a
Bool, and return a
(Bool -> Bool), that is, it returns a function from
Bool, so this is what we’re looking at:
(\_ -> magicCoin) :: Bool -> (Bool -> Bool)
Let’s set this up as a definition. We’ll call it magicBool:
magicBool :: Bool -> (Bool -> Bool) magicBool = \_ -> magicCoin
Those types don’t need brackets, because they naturally group up to the right. This is a function that takes two arguments! Let’s remove the brackets from the signature, and spell
magicCoin out as a lambda.
magicBool' :: Bool -> Bool -> Bool magicBool' = \_ -> (\_ -> True)
We’ve included parentheses for you to understand better, but they’re not needed here. There are actually two other ways we could write this, let’s see:
-- using two lambdas, -- without parentheses magicBool'1 :: Bool -> Bool -> Bool magicBool'1 = \_ -> \_ -> True -- using just one lambda magicBool'2 :: Bool -> Bool -> Bool magicBool'2 = \_ _ -> True
So, how would we use this? Well, It’s a function so we can just give it any
Bool value, then it’ll give us back the
magicCoin function as a value! Then, if we want to, we can give that another
Bool value, and it’ll give us back the value
This might seem useless at first, but let’s switch it into normal function syntax, and then we’ll look at a very useful function.
magicBool'' :: Bool -> Bool -> Bool magicBool'' _ _ = True
Ok, so what if we wanted a function that tells us if any one of two values is True? This is a function that is built into Haskell, you’ll see it later. If you’re this high, or you’re an adult, you can ride the scary ride!
Here’s how it could be made with what we know so far:
eitherTrue :: Bool -> Bool -> Bool eitherTrue False False = False eitherTrue _ _ = True
So if both the arguments are
False, we should reply with
False, however for everything else, the answer is going to be
True. (That is: either one is
True, or both are
Neat, isn’t it? This is a very useful function, and programmers use it all the time.
This process of making a function that returns a function itself is called currying after the mathematician Haskell Curry (yes, that’s why Haskell is named Haskell). This is how Haskell takes arguments. By doing more, we can get more than 2.
What about something more involved, like maybe adding two Integer numbers? Well, we’ll show you this here just now, but it’s really the topic of the next section, so don’t worry if you don’t quite get it yet.
We’re going to define a function called
plus that takes an
Int value (
Int is a whole number type), and returns a function that takes another
Int value and returns the first added to the second. We’re going to use the
(+) operator / function here. Just ignore it for now other than to know that it’s the way to add two numbers in Haskell.
plus :: Int -> Int -> Int plus x y = x + y plus' :: Int -> Int -> Int plus' = \x -> \y -> x + y increment :: Int -> Int increment = plus 1 increment' :: Int -> Int increment' = (\x -> \y -> x + y) 1 additionResult :: Int additionResult = plus 100 25
First we have plus, which takes two arguments and returns the first added to the second (using the
Next we have
plus' which does the exact same thing, but we’re using lambda syntax, and nesting one lambda in another.
increment, which uses the plus function and gives it one of its two arguments, which as we know will give us another function back. (Which will add one to whatever you give it). After that we have the same function done with lambdas:
increment’. Finally, we have a definition for the expression of adding 100 to 25.
This chapter might have seemed pretty simple or quite easy for you, but what we just saw is very deep, so it’s worth thinking about some more.
Haskell functions cannot take multiple arguments, only one each. However, what they can do is return another function. The way we get functions to work with more than one argument in Haskell is to wrap other functions around them, as we saw above. In other words, to make functions that give functions as their result.
If each of these functions that are returned also take an argument, we can create a kind of chain of arguments. Let’s see.
When we see this:
add :: Int -> Int -> Int add x y = x + y
It’s just a “sweeter”, easier, more convenient way of writing this:
add :: Int -> (Int -> Int) add = \x -> (\y -> x + y)
We can put a number into
x by applying the function to an argument, and we get a function back:
add 2 for example:
add :: Int -> (Int -> Int) add = \x -> (\y -> x + y) -- substitute 2 in for x. -- note that this is not Haskell code, -- it's just to show you what happens: -- add 2 is equal to \2 -> (\y -> 2 + y) -- add 2 is equal to \y -> 2 + y
If you wanted, you could call this a partial function application, but it’s really not what’s going on. All Haskell functions only take one argument, so all we’ve done is supply the
add function (which produces another function) with one argument.
When we write
add 2 3 what we’re actually doing is supplying a function-producing function with one argument (
add 2) and then immediately providing the function that gets produced by that with the
(add 2) 3.
Your homework is to read through this very well, and really try to understand it. Try out all of the program fragments in this chapter, and if you don’t understand any of this at all, write to us and tell us so we can adjust the book. All of the rest of your Haskell understanding relies on understanding this. We will explain it a little more in the next chapter, but it’s quite important.
If you’ve already learned another programming language, then this particular point will be incredibly difficult to understand for you. If you haven’t learned another programming language before, it’s going to be much easier because the way Haskell works is simpler, in the sense that it is not as complex. Of course if you’ve learned something complex and you think that is ordinary, when you see something simple it makes things very difficult to understand.
You’ll often hear us talking about things like “a function of two arguments” or, “put the letter 'x' in as the third argument”, but this is just an easier way to say what we mean. It’s not accurate, but we can use the short-hand form because we all understand that Haskell functions only take one argument, and when we say a function of two arguments, we really mean a function that produces a function that uses both their arguments in its inner body.
If you’ve enjoyed reading this, please consider purchasing a copy at Leanpub today
Please follow us, and check out our videos Follow @HappyLearnTutes
Also, Volume 2 is now in beta and being written! Show your support and register your interest at its Leanpub site.