[MUSIC] In this segment, I want to continue studying how Racket is a
dynamically typed language by telling you the truth about this cons primitive that
we have been using to build lists. And that truth is that we can also use
cons to make a pair. In fact, what cons really does is take
two arguments and make a pair and in Racket, as is common in dynamically typed
languages, all a list is, is some number of nested pairs that ends with the empty
list, that ends with null. So, it's probably easiest to see that by
just writing some code or using some code that uses this feature.
So, on this first line here, where I'm defining this variable pr, this is just a
pair with 1 in the first position. And in the second position another pair
that holds true and hi. So, this is not a list.
This is the sort of thing that in ML, we would have written as 1,true,hi, spelling
true correctly. but in Racket, we write it like this with cons because we use
cons to build a pair instead of comma and we can see how this will print in the RPL
by just writing pr and you see that what it actually does is it looks just like a
list except it puts this dot before the last element that says this is not a
list. This was the value that you get from
using cons with 1. And then, 1 more pair of cons with true
and hi. But let's compare that to the variable on
the next line, list. So there, I also use cons, which builds a
pair from 1. And then another cons, which builds a
pair from true, and then another cons.
And then, the last one is the string hi and null.
And that does make a list because a list is just some number of conses where the,
where in the cdr of each one, in the second position of each pair, you have
another cons until you get down to null until you get to the empty list.
So, that is what I mean by lists are just a particular kind of nested pair.
So, once we understand this, we see that cons just builds a pair.
In Racket, it's common to call them a cons cell.
And the you access the pieces of a cons cell is with car and cdr.
So, it turns out that car is really like MLs hash1 and cdr is like ML's hash2.
And that is all that is going on. So, given our pair value which remember,
is just nested pairs which prints slightly funny, if I take the cdr(cdr
pr), that gets me the string hi. It's the second component of the second
component. But if I had my list, and I said of cdr
sorry, of list, well then, I get a one element list back, because the cdr of the
cdr of list, is this pair of hi and null. If I wanted the actual hi, I would have
to take car of that, because if we take car of a pair, you get a string hi.
By the way, sometimes in Racket, we find ourselves writing car of cdr of cdr, and
for a long time in Racket and before its Scheme, there's a bunch of built-in
library functions that combine this So, you can use caddr.
And that is how it's pronounced. And all that it is, is there's a built in
function caddr that takes an x and returns car of cdr of cdr of x.
We could have defined this our self. But it's predefined for us in the
standard library. So now, we know the difference between
lists and pairs. As you might imagine, we have built in
functions for asking, do you have a list or a pair.
So, if we ask, is pr a list, the answer is false.
The only things that are lists are the empty list and cons is where you
eventually get down to the empty list. On the other hand, pr is a pair.
Anything built from cons is a pair. And if we do ask about list lst, that
variable, that is a list and it's also a pair.
So here, I'm just using the and primitive,
where I can ask a bunch of questions. I'll get the result true if they're all
true. So, that is our introduction to pairs
versus lists. I should warn you that there are a number
of built-in functions, like length, which works just fine on lists.
If I pass it a list with 3 elements,
I get 3. But if you try to pass it something that's not a list, even if it's
built from cons, you get an error message.
This error message is introducing a little bit of terminology.
Sometimes when we want to emphasize this distinction, we say that lists like lst
are proper lists, whereas something like pair, which is built from cons, but
doesn't end with null, we would call an improper list,
okay? So, that is the code I wanted to show you, lets go back quickly to the
slides. And ask why does, do we allow this, why
does Racket have this? Well, we know pairs are useful, they were useful in ML
and if you earn a dynamically typed language that isn't going to have a type
checker that distinguishes lists from pairs, then why have one kind of way to
build a pair and another kind of way to build a list.
Lets just use the same thing, in Racket's case, cons for building both.
So, in, unlike in ML, we don't need the comma for building a pair and the colon,
colon for building a list. Let's just use the same thing for both,
and programmers will just have to keep track of which things are proper lists
and which things are not. Now as a matter of style, if you have a
collection of unknown size, I don't know how many numbers I need to pass to a
function or something like that, you really should use a proper list.
That's the convention. That's what we want.
Put null at the end of your lists. But if you really just need a quick pair
or a triple, I just need to hold three things, then a pair or a pair with
another pair inside of it is perfectly fine.
We don't have triples built in to wreck it.
You really do have to say something like, let me just go back here, cons 1 of cons
of true onto hi. That would be a fine way to build
something that is like a triple, although it is really a pair with one thing in the
first position and then another. We could have just as well done it this
way, although this is a different data structure and it will print differently,
excuse me. One too many parantheses.
There we go. And this shows that we have an improper
list, we have a pair.
That's what this dot shows with hi in the second position and the pair 1 and true
in the first position and we can get the true out, for example, with let's see,
let me first define this to a variables so it's easier to see what I'm doing.
and then just say how about the cdr of the car of x abd that would be that true,
okay? So, this is perfectly reasonable when you
just need a small number of things, but as we'll see in the next section Racket
has some support for defining our own each of types and I would argue that's
even better style than just using cons which is hard to keep track of how you've
organized things and where things are defined.
And as we saw, in the RPL, as I was playing around with this, the list?
predicate built into the language returns true for proper lists, including the
empty list but not, it returns false for improper lists.
Whereas, the pair primitive returns true for anything made by cons.
And so, that includes all proper lists except the empty list and it also
includes any sort of pair.
