So here's how cond works. It's just a special form, COND.
So of course, it has a parenthesis at the beginning, and at the end.
We then have, in parentheses, n pairs of expressions, right? So I have a bracket,
because that's the convention. Semantically, it doesn't matter.
Just, syntactically, it's better styled at the bracket.
matter. You can use round parentheses if you
want. Then, 1 expression.
Then another expression and that branch, another one, another one.
The way this works is all these first ones are tests and all the second ones
are what to do if that test is true. So if the first one is true Then do the
second one. Else, if this is true, do this one.
Else, if this one. And you stop, and your result is the
first branch, where the thing on the left was true, and then you evaluate the thing
on the right, and that's your answer. Now, as a matter of style, it's very
important that your last branch typically be just true, which we write in Racket,
#t. This is your default case.
This is saying, in any other case, I want to evaluate this last expression, and
that's my. My answer.
If you do not do this and your last test expression also evaluates the false then
cond will return some strange void object which is a bad idea in Racket, it will
not produce an error here but probably it's going to return some result that
someone else doesn't want to use. And you'll end up confusing yourself.
So always make your last branch have as it's test a true, okay.
So let's go over here to DrRacket, here is the sum functions that I wrote in the
previous segment. So this first, this First one works on a
list of numbers that could have nested within them other lists of numbers and so
on, as deep as you want. And it's an error tab, anything in there
that's not a list or a number. And then the second version that if
there's some non-list or non-number nested somewhere on the list, we just
skip over it. [UNKNOWN] And we can rewrite each of
these just using cond, and so I'm going to do that just in a different file here
there we go. And, this will not be very difficult so
I'll call these sum 3 and sum 4 to continue what we were doing in the
previous section and I can have a cond which of course can have any number of
branches I want and the first branch will be that if the input X's is the No list,
the empty list, the results should be 0. Otherwise if the 1st element is a number,
so number of car of x's, then add the car of x's to the recursive sum of the cdr of
x's. That will end that branch.
Notice you can type round parentheses and if they match square brackets, Dr.
Racket will turn it into a square bracket for us.
And in any other case for this version, so for #t, I'll go ahead and assume that
the first element of xs is itself a list. So I know how to sum a list.
I call sum3, and then I need to sum3 the cdr of xs.
Codes that, and this should all be correct if we compare it to our other
version, I'm going to flip that over here, you'll see that we have the same
three cases. If it's null 0, the first number first
thing to list as a number, do this addition.
Otherwise do this addition but you'll probably agree with me that it's easier
to read laid out as this [UNKNOWN] we can see that three tests null, number and
true quite easily and then what to do in each case by the expression that follows
that test, k, so that's sum three now let me quickly do sum four.
It's the same idea. I'll have a con and if the list is empty
then return 0, if the first thing in the list is a number then, sorry, number car
of xs. And in fact it's exactly the same as
before, car of xs, sum4 For now cdr of x's, alright? Otherwise I have another
test in this version where I ask, well is x's a list? Because if it is, then I want
to do what I used to do just by the default assumption but this time I check
that it was the list. So you can see the difference between the
2 versions quite easily and in any other case.
Skip the car of xs and just cdr of xs and if you look back this is exactly like
some 2 just laid out nicely with the cond construct.
So that's our example. Now what I want to do is go back to the
slides and talk about one other issue, okay.
as before o sorry here's where I want to to go, okay.
So for both if and cond. I just didn't tell you this for if and
now I'm telling you for both. The test expression, that first
expression does not have to be true or false, #t or #f.
It turns out, it can be anything. It's never an error and it's fine.
So what is the semantic? The schemantics in Racket is that anything other than
false, counts as true. So, the only way to take the false
brancgh is if you have #f. But, to take the true branch you so not
need #t. You just need anything that is not #f.
This is very common in dyanamically type languages, some dynamicaaly type
languagees make other things false. Things like the empty list or the empty
string, or things like this. That's not true in Racket.
In Racket there's exactly one thing that's false, and that's #f.
Everything else counts as true. Now this makes no sense in a statically
typed language. In a statically typed language We would
insist that a conditional expression take something of type Buhl[UNKNOWN] for it's
first argument. Since everything has exactly one type,
there is no point in allowing anything to be in that first position.
But a language like Racket, you can You can do this.
Now, a lot of people consider this bad style.
A lot of people consider this convenient and okay.
And some people are kind of in between and say it depends on the situation.
I'm not a huge fan of this construct, but since it reinforces the idea That Racket
supports dynamic typing, I though I would show it to you.
So let's do couple quick examples here. so first of all let me just click run and
do something at the repel here. So what if I said if 34 then 14, l's 15.
Well since 34 is not false it must be true and I get 14.
Okay? So it's just that simple and I could say if empty list.
14 else 15, and I would get 14, and so on.
But if I saw hash false, then I get 15. So now, let me just paste in a quick
example of where this is useful, and I want to take the time to type it all out.
and you don't need this, okay? You could, you know, get by in, in Racket without
this feature. Woop.
There we go. So what this function does is it cou, it
takes in a list, just a list no nested list or anything, and counts how many
falses are in it. Okay? So let me just run this.
So we can see it in action. And so if I count falses of the list 34,
true, and hi, I should get 0. But if I add in here a couple falses,
maybe one at the beginning, one there, and how about a couple at the end.
Then I get 4. That's all it does, it counts how many
false's there are. Use cond, which we introduced here, and
we say that if the list is empty then there are 0 false's in it.
If the car of x's is not false, well here is one way to do that.
Right? If car of x's is anything other than false Then this test will be true.
And so we'll recursively count the falses in the cdr.
And in any other case, the only case that's left, it that the first thing in
the list was false. And then we would add 1 to count falses
of cdr of xes, okay? So that is an example of using this feature that
everything that is not #f is true. The only thing that is false is #f. But
the main idea in this segment was using cond for better style, and now we can use
it in all of our homework problems in Racket programming, rather than nested
if/then/else.
