446 lines
267 KiB
HTML
446 lines
267 KiB
HTML
|
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
|
||
|
|
<html><head><meta http-equiv="content-type" content="text/html; charset=utf-8"/><meta name="viewport" content="width=device-width, initial-scale=0.8"/><title>Intermezzo 1: Beginning Student Language</title><link rel="stylesheet" type="text/css" href="scribble.css" title="default"/><link rel="stylesheet" type="text/css" href="shared.css" title="default"/><link rel="stylesheet" type="text/css" href="figure.css" title="default"/><link rel="stylesheet" type="text/css" href="racket.css" title="default"/><link rel="stylesheet" type="text/css" href="manual-style.css" title="default"/><link rel="stylesheet" type="text/css" href="manual-racket.css" title="default"/><script type="text/javascript" src="scribble-common.js"></script><script type="text/javascript" src="figure.js"></script><script type="text/javascript" src="manual-racket.js"></script><!--[if IE 6]><style type="text/css">.SIEHidden { overflow: hidden; }</style><![endif]--></head><body id="scribble-racket-lang-org"><div class="tocset"><div class="tocview"><div class="tocviewlist tocviewlisttopspace"><div class="tocviewtitle"><table cellspacing="0" cellpadding="0"><tr><td style="width: 1em;"><a href="javascript:void(0);" title="Expand/Collapse" class="tocviewtoggle" onclick="TocviewToggle(this,"tocview_0");">▼</a></td><td></td><td><a href="index.html" class="tocviewlink" data-pltdoc="x">How to Design Programs, Second Edition</a></td></tr></table></div><div class="tocviewsublisttop" style="display: block;" id="tocview_0"><table cellspacing="0" cellpadding="0"><tr><td align="right"></td><td><a href="part_preface.html" class="tocviewlink" data-pltdoc="x">Preface</a></td></tr><tr><td align="right"></td><td><a href="part_prologue.html" class="tocviewlink" data-pltdoc="x">Prologue:<span class="mywbr"> </span> How to Program</a></td></tr><tr><td align="right">I </td><td><a href="part_one.html" class="tocviewlink" data-pltdoc="x">Fixed-<wbr></wbr>Size Data</a></td></tr><tr><td align="right"></td><td><a href="i1-2.html" class="tocviewselflink" data-pltdoc="x">Intermezzo 1: Beginning Student Language</a></td></tr><tr><td align="right">II </td><td><a href="part_two.html" class="tocviewlink" data-pltdoc="x">Arbitrarily Large Data</a></td></tr><tr><td align="right"></td><td><a href="i2-3.html" class="tocviewlink" data-pltdoc="x">Intermezzo 2: Quote, Unquote</a></td></tr><tr><td align="right">III </td><td><a href="part_three.html" class="tocviewlink" data-pltdoc="x">Abstraction</a></td></tr><tr><td align="right"></td><td><a href="i3-4.html" class="tocviewlink" data-pltdoc="x">Intermezzo 3: Scope and Abstraction</a></td></tr><tr><td align="right">IV </td><td><a href="part_four.html" class="tocviewlink" data-pltdoc="x">Intertwined Data</a></td></tr><tr><td align="right"></td><td><a href="i4-5.html" class="tocviewlink" data-pltdoc="x">Intermezzo 4: The Nature of Numbers</a></td></tr><tr><td align="right">V </td><td><a href="part_five.html" class="tocviewlink" data-pltdoc="x">Generative Recursion</a></td></tr><tr><td align="right"></td><td><a href="i5-6.html" class="tocviewlink" data-pltdoc="x">Intermezzo 5: The Cost of Computation</a></td></tr><tr><td align="right">VI </td><td><a href="part_six.html" class="tocviewlink" data-pltdoc="x">Accumulators</a></td></tr><tr><td align="right"></td><td><a href="part_epilogue.html" class="tocviewlink" data-pltdoc="x">Epilogue:<span class="mywbr"> </span> Moving On</a></td></tr></table></div></div><div class="tocviewlist"><table cellspacing="0" cellpadding="0"><tr><td style="width: 1em;"><a href="javascript:void(0);" title="Expand/Collapse" class="tocviewtoggle" onclick="TocviewToggle(this,"tocview_1");">►</a></td><td></td><td><a href="i1-2.html" class="tocviewselflink" data-pltdoc="x">Intermezzo 1: Beginning Student Language</a></td></tr></table><div class="tocviewsublistbottom" style="display: none;" id="tocview_1"><table cellspacing="0" cellpadding="0"><tr><td align="right"></td><td><a href="i1-2.html#%28part._.B.S.L_.Vocabulary%29" class="tocviewlink" data-pltdoc="x">BSL V
|
||
|
|
introduces the “basic words” of the language, suggests how to compose
|
||
|
|
“words” into “sentences,” and appeals to your knowledge of algebra for
|
||
|
|
an intuitive understanding of these “sentences.” While this kind of
|
||
|
|
introduction works to some extent, truly effective communication requires
|
||
|
|
some formal study.</p><p>In many ways, the analogy of <a href="part_one.html" data-pltdoc="x">Fixed-Size Data</a> is correct. A programming
|
||
|
|
language does have a vocabulary and a grammar, though programmers use the
|
||
|
|
word <span style="font-style: italic">syntax</span> for these elements. A sentence in BSL is an
|
||
|
|
expression or a definition. The grammar of BSL dictates how to form
|
||
|
|
these phrases. But not all grammatical sentences are meaningful—<wbr></wbr>neither
|
||
|
|
in English nor in a programming language. For example, the English
|
||
|
|
sentence “the cat is round” is a meaningful sentence, but “the brick is
|
||
|
|
a car” makes no sense even though it is completely grammatical. To
|
||
|
|
determine whether a sentence is meaningful, we must know the
|
||
|
|
<span style="font-style: italic">meaning</span> of a language; programmers call this
|
||
|
|
<span style="font-style: italic">semantics</span>.</p><p>This intermezzo presents BSL as if it were an extension of the familiar
|
||
|
|
language of arithmetic and algebra in middle school. After all,
|
||
|
|
computation starts with this form of simple mathematics, and we should
|
||
|
|
understand the connection between this mathematics and computing. The
|
||
|
|
first three sections present the syntax and semantics of a good portion
|
||
|
|
of<span class="refelem"><span class="refcolumn"><span class="refcontent">Programmers must eventually understand these principles of
|
||
|
|
<span style="font-weight: bold">computation</span>, but they are complementary to the principles of
|
||
|
|
<span style="font-weight: bold">design</span>.</span></span></span> BSL. Based on this new understanding of BSL, the
|
||
|
|
fourth resumes our discussion of errors. The remaining sections expand
|
||
|
|
this understanding to the complete language; the last one expands the
|
||
|
|
tools for expressing tests.</p><h3><a name="(part._.B.S.L_.Vocabulary)"></a>BSL Vocabulary</h3><p><a href="i1-2.html#%28counter._%28figure._fig~3alex-beginner%29%29" data-pltdoc="x">Figure <span class="FigureRef">39</span></a> introduces and defines BSL’s basic
|
||
|
|
vocabulary. It consists of literal constants, such as numbers or Boolean
|
||
|
|
values; names that have meaning according to BSL, for example,
|
||
|
|
<span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span> or <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span>; and names to which programs can give
|
||
|
|
meaning via <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span> or function parameters.</p><blockquote class="Figure"><blockquote class="Leftfigure"><blockquote class="FigureInside"><p><div class="SIntrapara">A <span class="RktVar">name</span> or a <span class="RktVar">variable</span> is a sequence of
|
||
|
|
characters, not including a space or one of the following:
|
||
|
|
<span class="RktInBG"><span class="hspace"></span><span class="RktIn">"</span><span class="hspace"></span></span> <span class="RktInBG"><span class="hspace"></span><span class="RktIn">,</span><span class="hspace"></span></span> <span class="RktInBG"><span class="hspace"></span><span class="RktIn">'</span><span class="hspace"></span></span> <span class="RktInBG"><span class="hspace"></span><span class="RktIn">`</span><span class="hspace"></span></span>
|
||
|
|
<span class="RktInBG"><span class="hspace"></span><span class="RktIn">(</span><span class="hspace"></span></span> <span class="RktInBG"><span class="hspace"></span><span class="RktIn">)</span><span class="hspace"></span></span> <span class="RktInBG"><span class="hspace"></span><span class="RktIn">[</span><span class="hspace"></span></span> <span class="RktInBG"><span class="hspace"></span><span class="RktIn">]</span><span class="hspace"></span></span>
|
||
|
|
<span class="RktInBG"><span class="hspace"></span><span class="RktIn">{</span><span class="hspace"></span></span> <span class="RktInBG"><span class="hspace"></span><span class="RktIn">}</span><span class="hspace"></span></span> <span class="RktInBG"><span class="hspace"></span><span class="RktIn">|</span><span class="hspace"></span></span> <span class="RktInBG"><span class="hspace"></span><span class="RktIn">;</span><span class="hspace"></span></span>
|
||
|
|
<span class="RktInBG"><span class="hspace"></span><span class="RktIn">#</span><span class="hspace"></span></span>:
|
||
|
|
</div><div class="SIntrapara"><ul><li><p>A <span class="RktVar">primitive</span> is a name to which BSL assigns meaning, for
|
||
|
|
example, <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span> or <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._sqrt%29%29" class="RktValLink" data-pltdoc="x">sqrt</a></span>.</p></li><li><p>A <span class="RktVar">variable</span> is a name without preassigned meaning.</p></li></ul></div></p><p><div class="SIntrapara">A <span class="RktVar">value</span> is one of:
|
||
|
|
</div><div class="SIntrapara"><ul><li><p>A <span class="RktVar">number</span> is one of:
|
||
|
|
<span class="RktVal">1</span>,
|
||
|
|
<span class="RktVal"><span class="nobreak">-1</span></span>,
|
||
|
|
<span class="RktVal">3/5</span>,
|
||
|
|
<span class="RktVal">1.22</span>,
|
||
|
|
<span class="RktVal">#i1.22</span><span class="RktMeta"></span>,
|
||
|
|
<span class="RktVal">0+1i</span>,
|
||
|
|
and so on.
|
||
|
|
The syntax for BSL numbers is complicated because it accommodates a range
|
||
|
|
of formats: positive and negative numbers, fractions and decimal numbers,
|
||
|
|
exact and inexact numbers, real and complex numbers, numbers in bases other
|
||
|
|
than <span class="RktVal">10</span>, and more. Understanding the precise notation for numbers
|
||
|
|
requires a thorough understanding of grammars and parsing, which is out of
|
||
|
|
scope for this intermezzo.</p></li><li><p>A <span class="RktVar">Boolean</span> is one of: <span class="RktVal">#true</span> or <span class="RktVal">#false</span>.</p></li><li><p>A <span class="RktVar">string</span> is one of:
|
||
|
|
<span class="RktVal">""</span>,
|
||
|
|
<span class="RktVal">"he says \"hello world\" to you"</span>,
|
||
|
|
<span class="RktVal">"doll"</span>,
|
||
|
|
and so on.
|
||
|
|
In general, it is a sequence of characters enclosed by a pair of
|
||
|
|
<span class="RktInBG"><span class="hspace"></span><span class="RktIn">"</span><span class="hspace"></span></span>.</p></li><li><p>An <span class="RktVar">image</span> is a png, jpg, tiff, and various other formats. We
|
||
|
|
intentionally omit a precise definition.</p></li></ul></div><div class="SIntrapara">We use <span class="RktSym">v</span>, <span class="RktSym">v-1</span>, <span class="RktSym">v-2</span> and the like when we wish to
|
||
|
|
say “any possible value.”</div></p></blockquote></blockquote><p class="Centertext"><span class="Legend"><span class="FigureTarget"><a name="(counter._(figure._fig~3alex-beginner))" x-target-lift="Figure"></a>Figure 39: </span>BSL core vocabulary</span></p></blockquote><p>Each of the explanations defines a set via a suggestive itemization of its
|
||
|
|
elements. Although it is possible to specify these collections in their
|
||
|
|
entirety, we consider this superfluous here and trust your intuition. Just
|
||
|
|
keep in mind that each of these sets may come with some extra elements.</p><h3><a name="(part._.B.S.L_.Grammar)"></a>BSL Grammar</h3><p><div class="SIntrapara"><a href="i1-2.html#%28counter._%28figure._fig~3asyn-beginner%29%29" data-pltdoc="x">Figure <span class="FigureRef">40</span></a> shows a large part of the BSL grammar,
|
||
|
|
which—<wbr></wbr>in comparison to other languages—<wbr></wbr>is extremely simple. As to
|
||
|
|
BSL’s expressive power, don’t let the looks deceive you. The first
|
||
|
|
action item, though, is to discuss how to read such grammars. Each
|
||
|
|
line<span class="refelem"><span class="refcolumn"><span class="refcontent">Reading a grammar aloud makes it sound like a data
|
||
|
|
definition. One could indeed use grammars to write down many of our data
|
||
|
|
definitions.</span></span></span> with a <span class="RktInBG"><span class="hspace"></span><span class="RktIn">=</span><span class="hspace"></span></span> introduces a <span style="font-style: italic">syntactic
|
||
|
|
category</span>; the best way to pronounce = is as “is one of” and | as
|
||
|
|
“or.” Wherever you see three dots, imagine as many repetitions of what
|
||
|
|
precedes the dots as you wish. This means, for example, that a
|
||
|
|
<span class="RktVar">program</span> is either nothing or a single occurrence of
|
||
|
|
<span class="RktVar">def-expr</span> or a sequence of two of them, or three, four, five, or
|
||
|
|
however many. Since this example is not particularly illuminating, let’s
|
||
|
|
look at the second syntactic category. It says that <span class="RktVar">def</span> is
|
||
|
|
either
|
||
|
|
<a name="(idx._(gentag._189))"></a>
|
||
|
|
<a name="(idx._(gentag._190))"></a>
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktVar">variable</span><span class="hspace"> </span><span class="RktVar">variable</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVar">expr</span><span class="RktPn">)</span></p></blockquote></div><div class="SIntrapara">because “as many as you wish” includes zero, or
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktVar">variable</span><span class="hspace"> </span><span class="RktVar">variable</span><span class="hspace"> </span><span class="RktVar">variable</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVar">expr</span><span class="RktPn">)</span></p></blockquote></div><div class="SIntrapara">which is one repetition, or
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktVar">variable</span><span class="hspace"> </span><span class="RktVar">variable</span><span class="hspace"> </span><span class="RktVar">variable</span><span class="hspace"> </span><span class="RktVar">variable</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVar">expr</span><span class="RktPn">)</span></p></blockquote></div><div class="SIntrapara">which uses two.</div></p><blockquote class="Figure"><blockquote class="Centerfigure"><blockquote class="FigureInside"><table cellspacing="0" cellpadding="0"><tr><td align="right" valign="baseline"><span class="hspace"> </span><span class="RktVar">program</span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">=</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktVar">def-expr</span><span class="hspace"> </span><span class="RktSym">...</span></td></tr><tr><td align="right" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td></tr><tr><td align="right" valign="baseline"><span class="hspace"> </span><span class="RktVar">def-expr</span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">=</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktVar">def</span></td></tr><tr><td align="right" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">|</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktVar">expr</span></td></tr><tr><td align="right" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td></tr><tr><td align="right" valign="baseline"><span class="hspace"> </span><span class="RktVar">def</span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">=</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktVar">variable</span><span class="hspace"> </span><span class="RktVar">variable</span><span class="hspace"> </span><span class="RktVar">variable</span><span class="hspace"> </span><span class="RktSym">...</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVar">expr</span><span class="RktPn">)</span></td></tr><tr><td align="right" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class
|
||
|
|
distinct font: <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span>, <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span>, and
|
||
|
|
<span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._else%29%29" class="RktStxLink" data-pltdoc="x">else</a></span>. According to the definition of BSL vocabulary, these
|
||
|
|
three words are names. What the vocabulary definition does not tell us is
|
||
|
|
that these names have a pre-defined meaning. In BSL, these words serve
|
||
|
|
as markers that differentiate some compound sentences from others, and in
|
||
|
|
acknowledgment of their role, such words are called <span style="font-style: italic">keywords</span>.</p><p><div class="SIntrapara">Now we are ready to state the purpose of a grammar. The grammar of a
|
||
|
|
programming language dictates how to form sentences from the vocabulary of
|
||
|
|
the grammar. Some sentences are just elements of vocabulary. For example,
|
||
|
|
according to <a href="i1-2.html#%28counter._%28figure._fig~3asyn-beginner%29%29" data-pltdoc="x">figure <span class="FigureRef">40</span></a> <span class="RktVal">42</span> is a sentence of
|
||
|
|
BSL:
|
||
|
|
</div><div class="SIntrapara"><ul><li><p>The first syntactic category says that a program is a
|
||
|
|
<span class="RktVar">def-expr</span>. Expressions may refer to the definitions.</p></li><li><p>The second one tells us that a <span class="RktVar">def-expr</span> is either a
|
||
|
|
<span class="RktVar">def</span> or an <span class="RktVar">expr</span>.<span class="refelem"><span class="refcolumn"><span class="refcontent">In DrRacket, a program
|
||
|
|
really consists of two distinct parts: the definitions area and the
|
||
|
|
expressions in the interactions area.</span></span></span></p></li><li><p>The last definition lists all ways of forming an
|
||
|
|
<span class="RktVar">expr</span>, and the second one is <span class="RktVar">value</span>.</p></li></ul></div><div class="SIntrapara">Since we know from <a href="i1-2.html#%28counter._%28figure._fig~3alex-beginner%29%29" data-pltdoc="x">figure <span class="FigureRef">39</span></a> that <span class="RktVal">42</span> is a
|
||
|
|
value, we have confirmation.</div></p><p>The interesting parts of the grammar show how to form compound sentences,
|
||
|
|
those built from other sentences. For example, the
|
||
|
|
<span class="RktVar">def</span> part tells us that a function definition is formed by
|
||
|
|
using “(”, followed by the keyword <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span>, followed by another
|
||
|
|
“(”, followed by a sequence of at least two variables, followed by
|
||
|
|
“)”, followed by an <span class="RktVar">expr</span>, and closed by a right parenthesis
|
||
|
|
“)” that matches the very first one. Note how
|
||
|
|
the leading keyword <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span> distinguishes definitions from
|
||
|
|
expressions.</p><p>Expressions (<span class="RktVar">expr</span>) come in six flavors: variables, constants,
|
||
|
|
primitive applications, (function) applications, and two varieties of
|
||
|
|
<span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span>itionals. While the first two are atomic sentences, the last
|
||
|
|
four are compound sentences. Like <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span>, the keyword
|
||
|
|
<span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span> distinguishes conditional expressions from applications.</p><p>Here are three examples of expressions: <span class="RktVal">"all"</span>, <span class="RktSym">x</span>, and
|
||
|
|
<span class="RktPn">(</span><span class="RktSym">f</span><span class="stt"> </span><span class="RktSym">x</span><span class="RktPn">)</span>. The first one belongs to the class of strings and is
|
||
|
|
therefore an expression. The second is a variable, and every variable is
|
||
|
|
an expression. The third is a function application, because <span class="RktSym">f</span>
|
||
|
|
and <span class="RktSym">x</span> are variables.</p><p>In contrast, these parenthesized sentences are not legal expressions:
|
||
|
|
<span class="RktPn">(</span><span class="RktSym">f</span><span class="stt"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="RktPn">)</span>, <span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span><span class="stt"> </span><span class="RktSym">x</span><span class="RktPn">)</span>, and <span class="RktPn">(</span><span class="RktPn">(</span><span class="RktSym">f</span><span class="stt"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktVal">10</span><span class="RktPn">)</span>. The
|
||
|
|
first one partially matches the shape of a function application but it
|
||
|
|
uses <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span> as if it were a variable. The second one fails to be
|
||
|
|
a correct <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span> expression because it contains a variable as the
|
||
|
|
second item and not a pair of expressions surrounded by parentheses. The
|
||
|
|
last one is neither a conditional nor an application because the first
|
||
|
|
part is an expression.</p><p>Finally, you may notice that the grammar does not mention white space:
|
||
|
|
blank spaces, tabs, and newlines. BSL is a permissive language. As
|
||
|
|
long as there is some white space between the elements of any sequence in
|
||
|
|
a program, DrRacket can understand your BSL programs. Good
|
||
|
|
programmers,<span class="refelem"><span class="refcolumn"><span class="refcontent">Keep in mind that two kinds of readers study
|
||
|
|
your BSL programs: people and DrRacket.</span></span></span> however, may not like what you
|
||
|
|
write. These programmers use white space to make their programs easily
|
||
|
|
readable. Most importantly, they adopt a style that favors human readers
|
||
|
|
over the software applications that process programs (such as DrRacket). They
|
||
|
|
pick up this style from carefully reading code examples in books, paying
|
||
|
|
attention to how they are formatted.</p><p><div class="SIntrapara"><a name="(counter._(exercise._ex~3alegal-ex1))"></a><span style="font-weight: bold">Exercise</span> 116. Take a look at the following sentences:</div><div class="SIntrapara"><ol><li><p><span class="RktSym">x</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="stt"> </span><span class="RktSym">y</span><span class="stt"> </span><span class="RktSym">z</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="stt"> </span><span class="RktSym">y</span><span class="stt"> </span><span class="RktSym">z</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktVal">0</span><span class="RktPn">)</span></p></li></ol></div><div class="SIntrapara">Explain why they are syntactically legal expressions <a href="i1-2.html#%28counter._%28exercise._ex~3alegal-ex1%29%29" class="ex-end" data-pltdoc="x"></a></div></p><p><div class="SIntrapara"><a name="(counter._(exercise._ex~3aillegal-ex1))"></a><span style="font-weight: bold">Exercise</span> 117. Consider the following sentences:</div><div class="SIntrapara"><ol><li><p><span class="RktPn">(</span><span class="RktVal">3</span><span class="stt"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="stt"> </span><span class="RktVal">4</span><span class="RktPn">)</span></p></li><li><p><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._number~3f%29%29" class="RktValLink" data-pltdoc="x">number?</a></span></p></li><li><p><span class="RktPn">(</span><span class="RktSym">x</span><span class="RktPn">)</span></p></li></ol></div><div class="SIntrapara">Explain why they are syntactically illegal. <a href="i1-2.html#%28counter._%28exercise._ex~3aillegal-ex1%29%29" class="ex-end" data-pltdoc="x"></a></div></p><p><div class="SIntrapara"><a name="(counter._(exercise._ex~3alegal-def1))"></a><span style="font-weight: bold">Exercise</span> 118. Take a look at the following sentences:</div><div class="SIntrapara"><ol><li><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym">f</span><span class="stt"> </span><span class="RktSym">x</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktSym">x</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym">f</span><span class="stt"> </span><span class="RktSym">x</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktSym">y</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rk
|
||
|
|
sentences:
|
||
|
|
</div><div class="SIntrapara"><ol><li><p><span class="RktPn">(</span><span class="RktSym">x</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._not%29%29" class="RktValLink" data-pltdoc="x">not</a></span><span class="stt"> </span><span class="RktSym">x</span><span class="RktPn">)</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">2</span><span class="stt"> </span><span class="RktVal">3</span><span class="RktPn">)</span></p></li></ol></div><div class="SIntrapara">Explain why the sentences are legal or illegal. Determine whether the legal
|
||
|
|
ones belong to the category <span class="RktVar">expr</span> or <span class="RktVar">def</span>. <a href="i1-2.html#%28counter._%28exercise._ex~3aillegal-exp1%29%29" class="ex-end" data-pltdoc="x"></a></div></p><p><span style="font-weight: bold">Note on Grammatical Terminology</span> The components of compound
|
||
|
|
sentences have names. We have introduced some of these names on an informal
|
||
|
|
basis. <a href="i1-2.html#%28counter._%28figure._fig~3aterminology%29%29" data-pltdoc="x">Figure <span class="FigureRef">41</span></a> provides a summary of the conventions.</p><p><div class="SIntrapara"><a name="(idx._(gentag._191))"></a>
|
||
|
|
</div><div class="SIntrapara"><blockquote class="Figure"><blockquote class="Leftfigure"><blockquote class="FigureInside"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktCmt">function application:</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktVar">function</span><span class="hspace"> </span><span class="RktVar">argument</span><span class="hspace"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="hspace"> </span><span class="RktVar">argument</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span></td></tr><tr><td><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktCmt">function definition:</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktVar">function-name</span><span class="hspace"> </span><span class="RktVar">parameter</span><span class="hspace"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="hspace"> </span><span class="RktVar">parameter</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">function-body</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span></td></tr><tr><td><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktCmt">conditional expression:</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">cond-clause</span></td></tr><tr><td><span class="hspace"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">cond-clause</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span></td></tr><tr><td><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span><span class="RktCmt"> clause </span></td></tr><tr><td><span class="RktPn">[</span><span class="RktVar">condition</span><span class="hspace"> </span><span class="RktVar">answer</span><span class="RktPn">]</span></td></tr></table></blockquote></blockquote><p class="Centertext"><span class="Legend"><span class="FigureTarget"><a name="(counter._(figure._fig~3aterminology))" x-target-lift="Figure"></a>Figure 41: </span>Syntactic naming conventions</span></p></blockquote></div></p><p>In addition to the terminology of <a href="i1-2.html#%28counter._%28figure._fig~3aterminology%29%29" data-pltdoc="x">figure <span class="FigureRef">41</span></a>, we say
|
||
|
|
<span style="font-style: italic">function header</span> for the second component of a definition.
|
||
|
|
Accordingly, the expression component is called a <span style="font-style: italic">function body</span>.
|
||
|
|
People who consider programming languages as a form of mathematics use
|
||
|
|
<span style="font-style: italic">left-hand side</span> for a header and <span style="font-style: italic">right-hand side</span> for the
|
||
|
|
body. On occasion, you also hear or read the term <span style="font-style: italic">actual
|
||
|
|
arguments</span> for the arguments in a function application. <span style="font-weight: bold">End</span></p><h3><a name="(part._.B.S.L_.Meaning)"></a>BSL Meaning</h3><p>When you hit the return key on your keyboard and ask DrRacket to evaluate an
|
||
|
|
expression, it uses the laws of arithmetic and algebra to obtain a
|
||
|
|
<span style="font-style: italic">value</span>. For the variant of BSL treated so far,
|
||
|
|
<a href="i1-2.html#%28counter._%28figure._fig~3alex-beginner%29%29" data-pltdoc="x">figure <span class="FigureRef">39</span></a> defines grammatically what a value
|
||
|
|
is—<wbr></wbr>the set of values is just a subset of all expressions. The set
|
||
|
|
includes <a href="part_one.html#%28tech._boolean%29" class="techoutside" data-pltdoc="x"><span class="techinside">Boolean</span></a>s, <a href="part_one.html#%28tech._string%29" class="techoutside" data-pltdoc="x"><span class="techinside">String</span></a>s, and <a href="part_one.html#%28tech._image%29" class="techoutside" data-pltdoc="x"><span class="techinside">Image</span></a>s.</p><p><div class="SIntrapara">The rules of evaluation come in two categories. An infinite
|
||
|
|
number of rules, like those of arithmetic, explain how to determine the
|
||
|
|
value of an application of a primitive operation to values:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">1</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktVal">2</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._-%29%29" class="RktValLink" data-pltdoc="x"><span class="nobreak">-</span></a></span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktVal">1</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktVal">1</span></td></tr><tr><td><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Remember <span class="RktSym">==</span> says that two expressions are equal according to
|
||
|
|
the laws of computation in BSL. But BSL arithmetic is more general
|
||
|
|
than just number crunching. It also includes rules for dealing with Boolean
|
||
|
|
values, strings, and so on:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._not%29%29" class="RktValLink" data-pltdoc="x">not</a></span><span class="hspace"> </span><span class="RktVal">#true</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktVal">#false</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._string~3d~3f%29%29" class="RktValLink" data-pltdoc="x">string=?</a></span><span class="hspace"> </span><span class="RktVal">"a"</span><span class="hspace"> </span><span class="RktVal">"a"</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktVal">#true</span></td></tr><tr><td><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span></td></tr></table></blockquote></div><div class="SIntrapara">And, like in algebra, you can always replace equals with equals;
|
||
|
|
see <a href="i1-2.html#%28counter._%28figure._fig~3aequals-for-equals%29%29" data-pltdoc="x">figure <span class="FigureRef">42</span></a> for a sample calculation.</div></p><blockquote class="Figure"><blockquote class="Centerfigure"><blockquote class="FigureInside"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._boolean~3f%29%29" class="RktValLink" data-pltdoc="x">boolean?</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._string-length%29%29" class="RktValLink" data-pltdoc="x">string-length</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._string-append%29%29" class="RktValLink" data-pltdoc="x">string-append</a></span><span class="hspace"> </span><span class="RktVal">"h"</span><span class="hspace"> </span><span class="RktVal">"w"</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="highlighted"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">3</span><span class="RktPn">)</span></span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktSym">==</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._boolean~3f%29%29" class="RktValLink" data-pltdoc="x">boolean?</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._string-length%29%29" class="RktValLink" data-pltdoc="x">string-length</a></span><span class="hspace"> </span><span class="highlighted"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._string-append%29%29" class="RktValLink" data-pltdoc="x">string-append</a></span><span class="stt"> </span><span class="RktVal">"h"</span><span class="stt"> </span><span class="RktVal">"w"</span><span class="RktPn">)</span></span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">4</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktSym">==</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._boolean~3f%29%29" class="RktValLink" data-pltdoc="x">boolean?</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-la
|
||
|
|
function to arguments. Suppose the program contains the definition
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktSym">x-1</span><span class="hspace"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="hspace"> </span><span class="RktSym">x-n</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktSym">f-body</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">Then an application of a function is governed by the law:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktSym">v-1</span><span class="hspace"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="hspace"> </span><span class="RktSym">v-n</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktSym">f-body</span></td></tr><tr><td><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktCmt">with all occurrences of </span><span class="RktSym">x-1</span><span class="stt"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="stt"> </span><span class="RktSym">x-n</span><span class="RktCmt"> </span></td></tr><tr><td><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktCmt">replaced with </span><span class="RktSym">v-1</span><span class="RktCmt"> </span>...<span class="RktCmt"> </span><span class="RktSym">v-n</span><span class="RktCmt">, respectively</span></td></tr></table></blockquote></div><div class="SIntrapara">Due to the history of languages such as BSL, we refer to this rule as
|
||
|
|
the <span style="font-style: italic">beta</span> or<span class="refelem"><span class="refcolumn"><span class="refcontent">See <a href="part_three.html#%28part._sec~3alambda-technical%29" data-pltdoc="x">Computing with <span class="RktSym"><span class="RktStxLink">lambda</span></span></a> for
|
||
|
|
more on this rule.</span></span></span> <span style="font-style: italic">beta-value</span> rule.</div></p><p><div class="SIntrapara">This rule is formulated as generally as possible, so it is best to look at a
|
||
|
|
concrete example. Say the definition is
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">poly</span><span class="hspace"> </span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktSym">y</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._expt%29%29" class="RktValLink" data-pltdoc="x">expt</a></span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">y</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">and DrRacket is given the expression <span class="RktPn">(</span><span class="RktSym">poly</span><span class="stt"> </span><span class="RktVal">3</span><span class="stt"> </span><span class="RktVal">5</span><span class="RktPn">)</span>. Then the first step in
|
||
|
|
an evaluation of the expression uses the beta rule:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><p><span class="RktPn">(</span><span class="RktSym">poly</span><span class="hspace"> </span><span class="RktVal">3</span><span class="hspace"> </span><span class="RktVal">5</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._expt%29%29" class="RktValLink" data-pltdoc="x">expt</a></span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">5</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktVal">8</span><span class="hspace"> </span><span class="RktVal">5</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktVal">13</span></p></blockquote></div></p><p><div class="SIntrapara">In addition to beta, we need rules that determine the value of
|
||
|
|
<span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span> expressions. These rules are algebraic even if they
|
||
|
|
are not explicitly taught as part of the standard curriculum. When
|
||
|
|
the first condition is <span class="RktVal">#false</span>, the first <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span>-line
|
||
|
|
disappears, leaving the rest of the lines intact:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktVal">#false</span><span class="hspace"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="RktPn">]</span><span class="hspace"> </span><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktCmt">first line removed</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">condition2</span><span class="hspace"> </span><span class="RktSym">answer2</span><span class="RktPn">]</span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">condition2</span><span class="hspace"> </span><span class="RktSym">answer2</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">This rule has the name <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span><span style="font-style: italic"></span><span style="vertical-align: sub; font-size: 80%"><span style="font-style: italic">false</span></span><span style="font-style: italic"></span>. Here is <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span><span style="font-style: italic"></span><span style="vertical-align: sub; font-size: 80%"><span style="font-style: italic">true</span></span><span style="font-style: italic"></span>:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktSym">answer-1</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktVal">#true</span><span class="hspace"> </span><span class="RktSym">answer-1</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">condition2</span><span class="hspace"> </span><span class="RktSym">answer2</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">The rule also applies when the first condition is <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._else%29%29" class="RktStxLink" data-pltdoc="x">else</a></span>.</div></p><p><div class="SIntrapara">Consider the following evaluation:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._zero~3f%29%29" class="RktValLink" data-pltdoc="x">zero?</a></span><span class="hspace"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">1</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="hspace"> </span><span class="RktVal">3</span><span class="hspace"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">1</span><span class="RktPn">)</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._else%29%29" class="RktStxLink" data-pltdoc="x">else</a></span><span class="hspace"> </span><span class="RktVal">3</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktSym">==</span><span class="hspace"> </span><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktCmt">by plain arithmetic and equals-for-equals</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktVal">#false</span><span class="hspace"> </span><span class="RktVal">1</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="hspace"> </span><span class="RktVal">3</span><span class="hspace"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">1</span><span class="RktPn">)</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._else%29%29" class="RktStxLink" data-pltdoc="x">else</a></span><span class="hspace"> </span><span c
|
||
|
|
of equals by equals, and both <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span> rules.</div></p><p><div class="SIntrapara"><a name="(counter._(exercise._ex~3aeval1))"></a><span style="font-weight: bold">Exercise</span> 121. Evaluate the following expressions step-by-step:
|
||
|
|
</div><div class="SIntrapara"><ol><li><table cellspacing="0" cellpadding="0" class="RktBlk" style="display: inline-table; vertical-align: text-top; margin-top: 0;"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="hspace"> </span><span class="RktVal">12</span><span class="hspace"> </span><span class="RktVal">8</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">2/3</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._-%29%29" class="RktValLink" data-pltdoc="x"><span class="nobreak">-</span></a></span><span class="hspace"> </span><span class="RktVal">20</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._sqrt%29%29" class="RktValLink" data-pltdoc="x">sqrt</a></span><span class="hspace"> </span><span class="RktVal">4</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></li><li><table cellspacing="0" cellpadding="0" class="RktBlk" style="display: inline-table; vertical-align: text-top; margin-top: 0;"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="hspace"> </span><span class="RktVal">0</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">#false</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3e%29%29" class="RktValLink" data-pltdoc="x">></a></span><span class="hspace"> </span><span class="RktVal">0</span><span class="hspace"> </span><span class="RktVal">1</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._string~3d~3f%29%29" class="RktValLink" data-pltdoc="x">string=?</a></span><span class="hspace"> </span><span class="RktVal">"a"</span><span class="hspace"> </span><span class="RktVal">"a"</span><span class="RktPn">)</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktSym">y</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktVal">3</span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktSym">y</span><span class="hspace"> </span><span class="RktSym">y</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">Show how DrRacket evaluates the following expressions, step-by-step:
|
||
|
|
</div><div class="SIntrapara"><ol><li><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktVal">1</span><span class="RktPn">)</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">19</span><span class="RktPn">)</span></p></li></ol></div><div class="SIntrapara">Use DrRacket’s stepper to confirm your computations. <a href="i1-2.html#%28counter._%28exercise._ex~3aeval%2Bdef1%29%29" class="ex-end" data-pltdoc="x"></a></div></p><h3><a name="(part._.Meaning_and_.Computing)"></a>Meaning and Computing</h3><p>The stepper tool in DrRacket mimics a student in a pre-algebra
|
||
|
|
course. Unlike you, the stepper is extremely good at applying the laws
|
||
|
|
of<span class="refelem"><span class="refcolumn"><span class="refcontent">A scientist calls the stepper a <span style="font-weight: bold">model</span> of DrRacket’s
|
||
|
|
evaluation mechanism. <a href="part_four.html#%28part._ch~3aevaluator%29" data-pltdoc="x">Refining Interpreters</a> presents another model, an
|
||
|
|
<span style="font-weight: bold">interpreter</span>.</span></span></span> arithmetic and algebra
|
||
|
|
as spelled out here, and it is also extremely fast.</p><p>You can, and you ought to, use the stepper when you don’t understand how a new
|
||
|
|
language construct works. The sections on <span style="font-weight: bold">Computing</span> suggest exercises
|
||
|
|
for this purpose, but you can make up your own examples, run them through the
|
||
|
|
stepper, and ponder why it takes certain steps.</p><p>Finally, you may also wish to use the stepper when you are surprised by the
|
||
|
|
result that a program computes. Using the stepper effectively in this way
|
||
|
|
requires practice. For example, it often means copying the program and pruning
|
||
|
|
unnecessary pieces. But once you understand how to use the stepper well this
|
||
|
|
way, you will find that this procedure clearly explains run-time errors and
|
||
|
|
logical mistakes in your programs.</p><h3><a name="(part._.B.S.L_.Errors)"></a>BSL Errors</h3><p>When DrRacket discovers that some parenthesized phrase does not belong to
|
||
|
|
BSL, it signals a <span style="font-style: italic">syntax error</span>. To determine whether
|
||
|
|
a<span class="refelem"><span class="refcolumn"><span class="refcontent">For a nearly full list of error messages, see the last
|
||
|
|
section of this intermezzo.</span></span></span> fully parenthesized program is syntactically
|
||
|
|
legal, DrRacket uses the grammar in <a href="i1-2.html#%28counter._%28figure._fig~3asyn-beginner%29%29" data-pltdoc="x">figure <span class="FigureRef">40</span></a> and reasons
|
||
|
|
along the lines explained above. Not all syntactically legal programs have
|
||
|
|
meaning, however.</p><p><div class="SIntrapara">When DrRacket evaluates a syntactically legal program and discovers that some
|
||
|
|
operation is used on the wrong kind of value, it raises a <span style="font-style: italic">run-time
|
||
|
|
error</span>. Consider the syntactically legal expression <span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">0</span><span class="RktPn">)</span>, which,
|
||
|
|
as you know from mathematics, has no value. Since BSL’s
|
||
|
|
calculations must be consistent with mathematics, DrRacket signals an error:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktErr">/:division by zero</span></p></td></tr></table></blockquote></div><div class="SIntrapara">Naturally it also signals an error when an expression such as <span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">0</span><span class="RktPn">)</span> is nested deeply inside of another expression:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktVal">20</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._-%29%29" class="RktValLink" data-pltdoc="x"><span class="nobreak">-</span></a></span><span class="hspace"> </span><span class="RktVal">10</span><span class="hspace"> </span><span class="RktVal">10</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktErr">/:division by zero</span></p></td></tr></table></blockquote></div></p><p><div class="SIntrapara">DrRacket’s behavior translates into our calculations as follows. When we find an
|
||
|
|
expression that is not a value and when the evaluation rules allow no further
|
||
|
|
simplification, we say the computation is <span style="font-style: italic">stuck</span>. This notion of
|
||
|
|
stuck corresponds to a run-time error. For example, computing the value of
|
||
|
|
the above expression leads to a stuck state:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktVal">20</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._-%29%29" class="RktValLink" data-pltdoc="x"><span class="nobreak">-</span></a></span><span class="hspace"> </span><span class="RktVal">10</span><span class="hspace"> </span><span class="RktVal">10</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktSym">==</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktVal">20</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktSym">==</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktVal">40</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">What this calculation also shows is that DrRacket eliminates the context of a
|
||
|
|
stuck expression as it signals an error. In this concrete example, it
|
||
|
|
eliminates the addition of <span class="RktVal">40</span> to the stuck expression <span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">0</span><span class="RktPn">)</span>.</div></p><p><div class="SIntrapara">Not all nested stuck expressions end up signaling errors. Suppose a program
|
||
|
|
contains this definition:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">my-divide</span><span class="hspace"> </span><span class="RktSym">n</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="hspace"> </span><span class="RktSym">n</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">"inf"</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._else%29%29" class="RktStxLink" data-pltdoc="x">else</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktSym">n</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">If you now apply <span class="RktSym">my-divide</span> to <span class="RktVal">0</span>, DrRacket calculates as follows:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">my-divide</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktSym">==</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="hspace"> </span><span class="RktVal">0</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">"inf"</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._else%29%29" class="RktStxLink" data-pltdoc="x">else</a></span><span class="hspace"> </span><span class="highlighted"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">0</span><span class="RktPn">)</span></span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">It would obviously be wrong to say that the function signals the
|
||
|
|
division-by-zero error now, even though an evaluation of the shaded
|
||
|
|
sub-expression may suggest it. The reason is that <span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="stt"> </span><span class="RktVal">0</span><span class="stt"> </span><span class="RktVal">0</span><span class="RktPn">)</span> evaluates
|
||
|
|
to <span class="RktVal">#true</span> and therefore the second <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span> clause does not play
|
||
|
|
any role:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">my-divide</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktSym">==</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="hspace"> </span><span class="RktVal">0</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">"inf"</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._else%29%29" class="RktStxLink" data-pltdoc="x">else</a></span><span class="hspace"> </span><span class="highlighted"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">0</span><span class="RktPn">)</span></span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktSym">==</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktVal">#true</span><span class="hspace"> </span><span class="RktVal">"inf"</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._else%29%29" class="RktStxLink" data-pltdoc="x">else</a></span><span class="hspace"> </span><span class="highlighted"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">0</span><span class="RktPn">)</span></span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktSym">==</span><span class="hspace"> </span><span class="RktVal">"inf"</span></td></tr></table></blockquote></div></p><p><div class="SIntrapara">Fortunately, our laws of evaluation take care of these situations
|
||
|
|
automatically. We just need to remember when they apply.
|
||
|
|
For example, in
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktVal">20</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="hspace"> </span><span class="RktVal">20</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="RktPn">)</span></p></blockquote></div><div class="SIntrapara">the addition cannot take place before the multiplication or
|
||
|
|
division. Similarly, the shaded division in
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="hspace"> </span><span class="RktVal">0</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">"inf"</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._else%29%29" class="RktStxLink" data-pltdoc="x">else</a></span><span class="hspace"> </span><span class="highlighted"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">0</span><span class="RktPn">)</span></span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">cannot be substituted for the complete <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span> expression
|
||
|
|
until the corresponding line is the first condition in the <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span>.</div></p><p><div class="SIntrapara">As a rule of thumb, it is best to keep the following in mind:
|
||
|
|
</div><div class="SIntrapara"><blockquote><p><span style="font-style: italic">Always choose the outermost and left-most nested expression that is
|
||
|
|
ready for evaluation.</span></p></blockquote></div><div class="SIntrapara">While this <a name="(idx._(gentag._192))"></a>guideline may look simplistic, it always explains BSL’s results.</div></p><p><div class="SIntrapara">In some cases, programmers also want to define functions that raise errors.
|
||
|
|
Recall the checked version of <span class="RktSym">area-of-disk</span> from <a href="part_one.html#%28part._sec~3ainput-errors%29" data-pltdoc="x">Input Errors</a>:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">checked-area-of-disk</span><span class="hspace"> </span><span class="RktSym">v</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._number~3f%29%29" class="RktValLink" data-pltdoc="x">number?</a></span><span class="hspace"> </span><span class="RktSym">v</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">area-of-disk</span><span class="hspace"> </span><span class="RktSym">v</span><span class="RktPn">)</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._else%29%29" class="RktStxLink" data-pltdoc="x">else</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._error%29%29" class="RktValLink" data-pltdoc="x">error</a></span><span class="hspace"> </span><span class="RktVal">"number expected"</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">Now imagine applying <span class="RktSym">checked-area-of-disk</span> to a string:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._-%29%29" class="RktValLink" data-pltdoc="x"><span class="nobreak">-</span></a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">checked-area-of-disk</span><span class="hspace"> </span><span class="RktVal">"a"</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">checked-area-of-disk</span><span class="hspace"> </span><span class="RktVal">10</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktSym">==</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._-%29%29" class="RktValLink" data-pltdoc="x"><span class="nobreak">-</span></a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._number~3f%29%29" class="RktValLink" data-pltdoc="x">number?</a></span><span class="hspace"> </span><span class="RktVal">"a"</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">area-of-disk</span><span class="hspace"> </span><span class="RktVal">"a"</span><span class="RktPn">)</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._else%29%29" class="RktStxLink" data-pltdoc="x">else</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._error%29%29" class="RktValLink" data-pltdoc="x">error</a></span><span class="hspace"> </span><span class="RktVal">"number expected"</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">checked-area-of-disk</span><span class="hspace"> </span><span class="RktVal">10</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktSym">==</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._-%29%29" class="RktValLink" data-pltdoc="x"><span class="nobreak">-</span></a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktVal">#false</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">area-of-disk</span><span class="hspace"> </span><span class="RktVal">"a"</span><span class="RktPn">)</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> &nbs
|
||
|
|
you do find out that its result is roughly <span class="RktVal">314</span>, your calculation
|
||
|
|
must eventually deal with the <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._error%29%29" class="RktValLink" data-pltdoc="x">error</a></span> expression, which is just
|
||
|
|
like a stuck expression. In short, the calculation ends in
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._error%29%29" class="RktValLink" data-pltdoc="x">error</a></span><span class="hspace"> </span><span class="RktVal">"number expected"</span><span class="RktPn">)</span></p></blockquote></div></p><h3><a name="(part._.Boolean_.Expressions)"></a>Boolean Expressions</h3><p>Our current definition of BSL omits <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._or%29%29" class="RktStxLink" data-pltdoc="x">or</a></span> and <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._and%29%29" class="RktStxLink" data-pltdoc="x">and</a></span>
|
||
|
|
expressions. Adding them provides a case study of how to study new
|
||
|
|
language constructs. We must first understand their syntax and then their
|
||
|
|
semantics.</p><p>Here is the revised grammar of expressions:</p><p><table cellspacing="0" cellpadding="0"><tr><td align="right" valign="baseline"><span class="hspace"> </span><span class="RktVar">expr</span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">=</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktSym">...</span></td></tr><tr><td align="right" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">|</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._and%29%29" class="RktStxLink" data-pltdoc="x">and</a></span><span class="hspace"> </span><span class="RktVar">expr</span><span class="hspace"> </span><span class="RktVar">expr</span><span class="RktPn">)</span></td></tr><tr><td align="right" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">|</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._or%29%29" class="RktStxLink" data-pltdoc="x">or</a></span><span class="hspace"> </span><span class="RktVar">expr</span><span class="hspace"> </span><span class="RktVar">expr</span><span class="RktPn">)</span></td></tr></table></p><p>The grammar says that <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._and%29%29" class="RktStxLink" data-pltdoc="x">and</a></span> and <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._or%29%29" class="RktStxLink" data-pltdoc="x">or</a></span> are keywords, each
|
||
|
|
followed by two expressions. They are <span style="font-weight: bold">not</span> function applications.</p><p><div class="SIntrapara">To understand why <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._and%29%29" class="RktStxLink" data-pltdoc="x">and</a></span> and <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._or%29%29" class="RktStxLink" data-pltdoc="x">or</a></span> are not BSL-defined
|
||
|
|
functions, we must look at their pragmatics first.
|
||
|
|
Suppose we need to formulate a condition that determines whether <span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktSym">n</span><span class="RktPn">)</span>
|
||
|
|
is <span class="RktSym">r</span>:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">check</span><span class="hspace"> </span><span class="RktSym">n</span><span class="hspace"> </span><span class="RktSym">r</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._and%29%29" class="RktStxLink" data-pltdoc="x">and</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._not%29%29" class="RktValLink" data-pltdoc="x">not</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="hspace"> </span><span class="RktSym">n</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktSym">n</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">r</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">We formulate the condition as an <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._and%29%29" class="RktStxLink" data-pltdoc="x">and</a></span> combination because we don’t
|
||
|
|
wish to divide by <span class="RktVal">0</span> accidentally. Now let’s apply
|
||
|
|
<span class="RktSym">check</span> to <span class="RktVal">0</span> and <span class="RktVal">1/5</span>:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">check</span><span class="hspace"> </span><span class="RktVal">0</span><span class="hspace"> </span><span class="RktVal">1/5</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktSym">==</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._and%29%29" class="RktStxLink" data-pltdoc="x">and</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._not%29%29" class="RktValLink" data-pltdoc="x">not</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="hspace"> </span><span class="RktVal">0</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="hspace"> </span><span class="highlighted"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">0</span><span class="RktPn">)</span></span><span class="hspace"> </span><span class="RktVal">1/5</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">If <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._and%29%29" class="RktStxLink" data-pltdoc="x">and</a></span> were an ordinary operation, we would have to evaluate
|
||
|
|
both sub-expressions, and doing so would trigger an error.
|
||
|
|
Instead <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._and%29%29" class="RktStxLink" data-pltdoc="x">and</a></span> simply does not evaluate the second expression when
|
||
|
|
the first one is <span class="RktVal">#false</span>, meaning, <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._and%29%29" class="RktStxLink" data-pltdoc="x">and</a></span>
|
||
|
|
<span style="font-style: italic">short-circuits</span> evaluation.</div></p><p><div class="SIntrapara">It would be easy to formulate evaluation rules for <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._and%29%29" class="RktStxLink" data-pltdoc="x">and</a></span> and
|
||
|
|
<span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._or%29%29" class="RktStxLink" data-pltdoc="x">or</a></span>. Another way to explain their meaning is to
|
||
|
|
translate them into other expressions:<span class="refelem"><span class="refcolumn"><span class="refcontent">To make sure
|
||
|
|
<span class="RktVar">expr-2</span> evaluates to a Boolean value, these abbreviations should
|
||
|
|
use <span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._if%29%29" class="RktStxLink" data-pltdoc="x">if</a></span><span class="stt"> </span><span class="RktVar">expr-2</span><span class="stt"> </span><span class="RktVal">#true</span><span class="stt"> </span><span class="RktVal">#false</span><span class="RktPn">)</span> instead of just
|
||
|
|
<span class="RktVar">expr-2</span>. We gloss over this detail here.</span></span></span>
|
||
|
|
</div><div class="SIntrapara"><blockquote><table cellspacing="0" cellpadding="0"><tr><td valign="top"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._and%29%29" class="RktStxLink" data-pltdoc="x">and</a></span><span class="hspace"> </span><span class="RktVar">expr-1</span><span class="hspace"> </span><span class="RktVar">expr-2</span><span class="RktPn">)</span></td><td valign="top"><p><span class="hspace"> </span></p></td><td valign="top"><p>is short for</p></td><td valign="top"><p><span class="hspace"> </span></p></td><td valign="top"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktVar">expr-1</span><span class="hspace"> </span><span class="RktVar">expr-2</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._else%29%29" class="RktStxLink" data-pltdoc="x">else</a></span><span class="hspace"> </span><span class="RktVal">#false</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr></table></td></tr></table></blockquote></div><div class="SIntrapara">and
|
||
|
|
</div><div class="SIntrapara"><blockquote><table cellspacing="0" cellpadding="0"><tr><td valign="top"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._or%29%29" class="RktStxLink" data-pltdoc="x">or</a></span><span class="hspace"> </span><span class="RktVar">expr-1</span><span class="hspace"> </span><span class="RktVar">expr-2</span><span class="RktPn">)</span></td><td valign="top"><p><span class="hspace"> </span></p></td><td valign="top"><p>is short for</p></td><td valign="top"><p><span class="hspace"> </span></p></td><td valign="top"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktVar">expr-1</span><span class="hspace"> </span><span class="RktVal">#true</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._else%29%29" class="RktStxLink" data-pltdoc="x">else</a></span><span class="hspace"> </span><span class="RktVar">expr-2</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr></table></td></tr></table></blockquote></div><div class="SIntrapara">So if you are ever in doubt about how to evaluate an <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._and%29%29" class="RktStxLink" data-pltdoc="x">and</a></span> or
|
||
|
|
<span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._or%29%29" class="RktStxLink" data-pltdoc="x">or</a></span> expression, use the above equivalences to calculate. But we
|
||
|
|
trust that you understand these operations intuitively, and that is almost
|
||
|
|
always enough.</div></p><p><div class="SIntrapara"><a name="(counter._(exercise._ex~3aif-cond))"></a><span style="font-weight: bold">Exercise</span> 123. The use of <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._if%29%29" class="RktStxLink" data-pltdoc="x">if</a></span> may have surprised you in
|
||
|
|
another way because this intermezzo does not mention this form elsewhere.
|
||
|
|
In short, the intermezzo appears to explain <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._and%29%29" class="RktStxLink" data-pltdoc="x">and</a></span> with a form that
|
||
|
|
has no explanation either. At this point, we are relying on your intuitive
|
||
|
|
understanding of <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._if%29%29" class="RktStxLink" data-pltdoc="x">if</a></span> as a short-hand for <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span>. Write down
|
||
|
|
a rule that shows how to reformulate
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._if%29%29" class="RktStxLink" data-pltdoc="x">if</a></span><span class="hspace"> </span><span class="RktVar">expr-test</span><span class="hspace"> </span><span class="RktVar">expr-then</span><span class="hspace"> </span><span class="RktVar">expr-else</span><span class="RktPn">)</span></p></blockquote></div><div class="SIntrapara">as a <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span> expression. <a href="i1-2.html#%28counter._%28exercise._ex~3aif-cond%29%29" class="ex-end" data-pltdoc="x"></a></div></p><h3><a name="(part._.Constant_.Definitions)"></a>Constant Definitions</h3><p><div class="SIntrapara">Programs consist not only of function definitions but also of constant
|
||
|
|
definitions, but these weren’t included in our first grammar.
|
||
|
|
So here is an extended grammar that includes constant definitions:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0"><tr><td align="right" valign="baseline"><span class="hspace"> </span><span class="RktVar">definition</span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">=</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktSym">...</span></td></tr><tr><td align="right" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">|</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktVar">name</span><span class="hspace"> </span><span class="RktVar">expr</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">The shape of a constant definition is similar to that of a function
|
||
|
|
definition. While the keyword <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span> distinguishes constant
|
||
|
|
definitions from expressions, it does not differentiate from
|
||
|
|
function<span class="refelem"><span class="refcolumn"><span class="refcontent">As it turns out, DrRacket has another way of
|
||
|
|
dealing with function definitions; see <a href="part_three.html#%28part._ch~3a3lambda%29" data-pltdoc="x">Nameless Functions</a>.</span></span></span>
|
||
|
|
definitions. For that, a human reader must look at the second component of
|
||
|
|
the definition.</div></p><p><div class="SIntrapara">Next we must understand what a constant definition means. For a constant
|
||
|
|
definition with a literal constant on the right-hand side, such as
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">RADIUS</span><span class="hspace"> </span><span class="RktVal">5</span><span class="RktPn">)</span></p></blockquote></div><div class="SIntrapara">the variable is just a short-hand for the value. Wherever DrRacket encounters
|
||
|
|
<span class="RktSym">RADIUS</span> during an evaluation, it replaces it with <span class="RktVal">5</span>.</div></p><p><div class="SIntrapara">For a definition with a proper expression on the right-hand side, say,
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">DIAMETER</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktSym">RADIUS</span><span class="RktPn">)</span><span class="RktPn">)</span></p></blockquote></div><div class="SIntrapara">we must immediately determine the value of the expression. This process
|
||
|
|
makes use of whatever definitions precede this constant definition. Hence,
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">RADIUS</span><span class="hspace"> </span><span class="RktVal">5</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">DIAMETER</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktSym">RADIUS</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">is equivalent to
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">RADIUS</span><span class="hspace"> </span><span class="RktVal">5</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">DIAMETER</span><span class="hspace"> </span><span class="RktVal">10</span><span class="RktPn">)</span></td></tr></table></blockquote></div></p><p><div class="SIntrapara">This process even works when function definitions are involved:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">RADIUS</span><span class="hspace"> </span><span class="RktVal">10</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">DIAMETER</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktSym">RADIUS</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">area</span><span class="hspace"> </span><span class="RktSym">r</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktVal">3.14</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktSym">r</span><span class="hspace"> </span><span class="RktSym">r</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">AREA-OF-RADIUS</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">area</span><span class="hspace"> </span><span class="RktSym">RADIUS</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">As DrRacket steps through this sequence of definitions, it first determines
|
||
|
|
that <span class="RktSym">RADIUS</span> stands for <span class="RktVal">10</span>, <span class="RktSym">DIAMETER</span> for
|
||
|
|
<span class="RktVal">20</span>, and <span class="RktSym">area</span> is the name of a function. Finally, it
|
||
|
|
evaluates <span class="RktPn">(</span><span class="RktSym">area</span><span class="stt"> </span><span class="RktSym">RADIUS</span><span class="RktPn">)</span> to <span class="RktVal">314</span> and associates
|
||
|
|
<span class="RktSym">AREA-OF-RADIUS</span> with that value.</div></p><p><div class="SIntrapara">Mixing constant and function definitions gives rise to a new kind of
|
||
|
|
run-time error, too. Take a look at this program:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">RADIUS</span><span class="hspace"> </span><span class="RktVal">10</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">DIAMETER</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktSym">RADIUS</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">AREA-OF-RADIUS</span><span class="hspace"> </span><span class="RktPn">(</span><span class="highlighted"><span class="RktSym">area</span></span><span class="hspace"> </span><span class="RktSym">RADIUS</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">area</span><span class="hspace"> </span><span class="RktSym">r</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktVal">3.14</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktSym">r</span><span class="hspace"> </span><span class="RktSym">r</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">It is like the one above with the last two definitions swapped. For the
|
||
|
|
first two definitions, evaluation proceeds as before. For the third one,
|
||
|
|
however, evaluation goes wrong. The process calls for the evaluation of
|
||
|
|
<span class="RktPn">(</span><span class="RktSym">area</span><span class="stt"> </span><span class="RktSym">RADIUS</span><span class="RktPn">)</span>. While the definition of <span class="RktSym">RADIUS</span> precedes
|
||
|
|
this expression, the definition of <span class="RktSym">area</span> has not yet been
|
||
|
|
encountered. If you were to evaluate the program with DrRacket, you would
|
||
|
|
therefore get an error, explaining that “this function is not defined.”
|
||
|
|
So be careful to use functions in constant definitions only when
|
||
|
|
you know they are defined.</div></p><p><div class="SIntrapara"><a name="(counter._(exercise._ex~3adef-var-sem3))"></a><span style="font-weight: bold">Exercise</span> 124. Evaluate the following program, step-by-step:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">PRICE</span><span class="hspace"> </span><span class="RktVal">5</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">SALES-TAX</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktVal">0.08</span><span class="hspace"> </span><span class="RktSym">PRICE</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">TOTAL</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktSym">PRICE</span><span class="hspace"> </span><span class="RktSym">SALES-TAX</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">Does the evaluation of the following program
|
||
|
|
signal an error?
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">COLD-F</span><span class="hspace"> </span><span class="RktVal">32</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">COLD-C</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">fahrenheit->celsius</span><span class="hspace"> </span><span class="RktSym">COLD-F</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">fahrenheit->celsius</span><span class="hspace"> </span><span class="RktSym">f</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktVal">5/9</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._-%29%29" class="RktValLink" data-pltdoc="x"><span class="nobreak">-</span></a></span><span class="hspace"> </span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktVal">32</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">How about the next one?
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">LEFT</span><span class="hspace"> </span><span class="RktVal"><span class="nobreak">-1</span>00</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">RIGHT</span><span class="hspace"> </span><span class="RktVal">100</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktVal">5</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._expt%29%29" class="RktValLink" data-pltdoc="x">expt</a></span><span class="hspace"> </span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">10</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym"><a href="https://htdp.org/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="6600262a232032">[email protected]</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktSym">LEFT</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym"><a href="https://htdp.org/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="c2a482908b858a96">[email protected]</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktSym">RIGHT</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">Check your computations with DrRacket’s stepper. <a href="i1-2.html#%28counter._%28exercise._ex~3adef-var-sem3%29%29" class="ex-end" data-pltdoc="x"></a></div></p><h3><a name=
|
||
|
|
construct. We have therefore saved its explanation for last. Here is the
|
||
|
|
grammar:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0"><tr><td align="right" valign="baseline"><span class="hspace"> </span><span class="RktVar">definition</span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">=</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktSym">...</span></td></tr><tr><td align="right" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">|</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="hspace"> </span><span class="RktVar">name</span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktVar">name</span><span class="hspace"> </span><span class="RktSym">...</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">A structure type definition is a third form of definition. The keyword
|
||
|
|
distinguishes it from both function and constant definitions.</div></p><p><div class="SIntrapara">Here is a simple example:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="hspace"> </span><span class="RktSym">point</span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktSym">y</span><span class="hspace"> </span><span class="RktSym">z</span><span class="RktPn">]</span><span class="RktPn">)</span></p></blockquote></div><div class="SIntrapara">Since <span class="RktSym">point</span>, <span class="RktSym">x</span>, <span class="RktSym">y</span>, and <span class="RktSym">z</span> are variables and
|
||
|
|
the parentheses are placed according to the grammatical pattern, it is a
|
||
|
|
proper definition of a structure type. In contrast, these two parenthesized sentences
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">point</span><span class="hspace"> </span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktSym">y</span><span class="hspace"> </span><span class="RktSym">z</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="hspace"> </span><span class="RktSym">point</span><span class="hspace"> </span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktSym">y</span><span class="hspace"> </span><span class="RktSym">z</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">are illegal definitions because <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span> is not followed
|
||
|
|
by a single variable name and a sequence of variables in parentheses.</div></p><p><div class="SIntrapara">While the syntax of <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span> is straightforward, its meaning is
|
||
|
|
difficult to spell out with evaluation rules. As mentioned several times, a
|
||
|
|
<span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span> definition defines several functions at once: a
|
||
|
|
constructor, several selectors, and a predicate. Thus the evaluation of
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="hspace"> </span><span class="RktSym">c</span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">s-1</span><span class="hspace"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="hspace"> </span><span class="RktSym">s-n</span><span class="RktPn">]</span><span class="RktPn">)</span></p></blockquote></div><div class="SIntrapara">introduces the following functions into the program:
|
||
|
|
</div><div class="SIntrapara"><ol><li><p><span class="RktSym">make-c</span>: a <span style="font-style: italic">constructor</span>;</p></li><li><p><span class="RktSym">c-s-1...</span><span class="stt"> </span><span class="RktSym">c-s-n</span>: a series of <span style="font-style: italic">selectors</span>; and</p></li><li><p><span class="RktSym">c?</span>: a <span style="font-style: italic">predicate</span>.</p></li></ol></div><div class="SIntrapara">These functions have the same status as <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span>, <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._-%29%29" class="RktValLink" data-pltdoc="x"><span class="nobreak">-</span></a></span>, or
|
||
|
|
<span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span>. Before we can understand the rules that govern these new
|
||
|
|
functions, however, we must return to the definition of values. After all,
|
||
|
|
one purpose of a <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span> is to introduce a class of
|
||
|
|
values that is distinct from all existing values.</div></p><p><div class="SIntrapara">Simply put, the use of <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span> extends the universe of
|
||
|
|
values. To start with, it now also contains structures, which compound
|
||
|
|
several values into one. When a program contains a <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span>
|
||
|
|
definition, its evaluation modifies the definition of values:
|
||
|
|
</div><div class="SIntrapara"><blockquote><p><div class="SIntrapara">A <span class="RktVar">value</span> is one of: a <span class="RktVar">number</span>, a <span class="RktVar">Boolean</span>, a <span class="RktVar">string</span>, an <span class="RktVar">image</span>,
|
||
|
|
</div><div class="SIntrapara"><ul><li><p><div class="SIntrapara">or a structure value:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">make-c</span><span class="RktMeta"></span><span class="hspace"> </span><span class="RktMeta"></span><span class="RktSym">_value-1</span><span class="RktMeta"></span><span class="hspace"> </span><span class="RktMeta"></span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="RktMeta"></span><span class="hspace"> </span><span class="RktMeta"></span><span class="RktSym">_value-n</span><span class="RktPn">)</span><span class="RktMeta"></span></td></tr></table></blockquote></div><div class="SIntrapara">assuming a structure type <span class="RktSym">c</span> is defined.</div></p></li></ul></div></p></blockquote></div><div class="SIntrapara">For example, the definition of <span class="RktSym">point</span> adds values of this shape:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktVal"><span class="nobreak">-1</span></span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="hspace"> </span><span class="RktVal">"one"</span><span class="hspace"> </span><span class="RktVal">"hello"</span><span class="hspace"> </span><span class="RktVal">"world"</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">"one"</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktVal"><span class="nobreak">-1</span></span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span></td></tr></table></blockquote></div></p><p><div class="SIntrapara">Now we are in a position to understand the evaluation rules of the new
|
||
|
|
functions. If <span class="RktSym">c-s-1</span> is applied to a <span class="RktSym">c</span> structure, it
|
||
|
|
returns the first component of the value. Similarly, the second selector
|
||
|
|
extracts the second component, the third selector the third component, and
|
||
|
|
so on. The relationship between the new data constructor and the selectors
|
||
|
|
is best characterized with <span style="font-style: italic">n</span> equations added to BSL’s rules:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">c-s-1</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">make-c</span><span class="hspace"> </span><span class="RktSym">V-1</span><span class="hspace"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="hspace"> </span><span class="RktSym">V-n</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktSym">V-1</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym">c-s-n</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">make-c</span><span class="hspace"> </span><span class="RktSym">V-1</span><span class="hspace"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="hspace"> </span><span class="RktSym">V-n</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktSym">V-n</span></td></tr></table></blockquote></div><div class="SIntrapara">For our running example, we get the specific equations
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">point-x</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="hspace"> </span><span class="RktSym">V</span><span class="hspace"> </span><span class="RktSym">U</span><span class="hspace"> </span><span class="RktSym">W</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktSym">V</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym">point-y</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="hspace"> </span><span class="RktSym">V</span><span class="hspace"> </span><span class="RktSym">U</span><span class="hspace"> </span><span class="RktSym">W</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktSym">U</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym">point-z</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="hspace"> </span><span class="RktSym">V</span><span class="hspace"> </span><span class="RktSym">U</span><span class="hspace"> </span><span class="RktSym">W</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktSym">W</span></td></tr></table></blockquote></div><div class="SIntrapara">When DrRacket sees <span class="RktPn">(</span><span class="RktSym">point-y</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="stt"> </span><span class="RktVal">3</span><span class="stt"> </span><span class="RktVal">4</span><span class="stt"> </span><span class="RktVal">5</span><span class="RktPn">)</span><span class="RktPn">)</span>, it replaces
|
||
|
|
the expression with <span class="RktVal">4</span> while
|
||
|
|
<span class="RktPn">(</span><span class="RktSym">point-x</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">2</span><span class="stt"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktVal">4</span><span class="stt"> </span><span class="RktVal">5</span><span class="RktPn">)</span><span class="RktPn">)</span> evaluates
|
||
|
|
to <span class="RktPn">(</span><span class="RktSym">make-point</span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">2</span><span class="stt"> </span><span class="RktVal">3</span><span class="RktPn">)</span>.</div></p><p><div class="SIntrapara">The predicate <span class="RktSym">c?</span> can be applied to any value. It returns
|
||
|
|
<span class="RktVal">#true</span> if the value is of kind <span class="RktSym">c</span> and <span class="RktVal">#false</span>
|
||
|
|
otherwise. We can translate both parts into two equations:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">c?</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">make-c</span><span class="hspace"> </span><span class="RktSym">V-1</span><span class="hspace"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="hspace"> </span><span class="RktSym">V-n</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktVal">#true</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym">c?</span><span class="hspace"> </span><span class="RktSym">V</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktVal">#false</span></td></tr></table></blockquote></div><div class="SIntrapara">if <span class="RktSym">V</span> is a value not constructed with <span class="RktSym">make-c</span>.
|
||
|
|
Again, the equations are best understood in terms of our example:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym">point?</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="hspace"> </span><span class="RktSym">U</span><span class="hspace"> </span><span class="RktSym">V</span><span class="hspace"> </span><span class="RktSym">W</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktVal">#true</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym">point?</span><span class="hspace"> </span><span class="RktSym">X</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">==</span><span class="hspace"> </span><span class="RktVal">#false</span></td></tr></table></blockquote></div><div class="SIntrapara">if <span class="RktSym">X</span> is a value but not a <span class="RktSym">point</span> structure.</div></p><p><div class="SIntrapara"><a name="(counter._(exercise._ex~3adefine-struct-syn))"></a><span style="font-weight: bold">Exercise</span> 125. Discriminate the legal from the illegal
|
||
|
|
sentences:
|
||
|
|
</div><div class="SIntrapara"><ol><li><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="stt"> </span><span class="RktSym">oops</span><span class="stt"> </span><span class="RktPn">[</span><span class="RktPn">]</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="stt"> </span><span class="RktSym">child</span><span class="stt"> </span><span class="RktPn">[</span><span class="RktSym">parents</span><span class="stt"> </span><span class="RktSym">dob</span><span class="stt"> </span><span class="RktSym">date</span><span class="RktPn">]</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym">child</span><span class="stt"> </span><span class="RktSym">person</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktPn">[</span><span class="RktSym">dob</span><span class="stt"> </span><span class="RktSym">date</span><span class="RktPn">]</span><span class="RktPn">)</span></p></li></ol></div><div class="SIntrapara">Explain why the sentences are legal or illegal. <a href="i1-2.html#%28counter._%28exercise._ex~3adefine-struct-syn%29%29" class="ex-end" data-pltdoc="x"></a></div></p><p><div class="SIntrapara"><a name="(counter._(exercise._ex~3adefine-struct-value))"></a><span style="font-weight: bold">Exercise</span> 126. Identify the <span class="RktVar">value</span>s among the
|
||
|
|
following expressions, assuming the definitions area contains these
|
||
|
|
structure type definitions:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="hspace"> </span><span class="RktSym">point</span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktSym">y</span><span class="hspace"> </span><span class="RktSym">z</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="hspace"> </span><span class="RktSym">none</span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr></table></blockquote></div></p><p><div class="SIntrapara"><ol><li><p><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">2</span><span class="stt"> </span><span class="RktVal">3</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">2</span><span class="stt"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktVal">4</span><span class="stt"> </span><span class="RktVal">5</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktVal">3</span><span class="stt"> </span><span class="RktVal">4</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym">make-none</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym">point-x</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym">make-point</span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">2</span><span class="stt"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktVal">4</span><span class="stt"> </span><span class="RktVal">5</span><span class="RktPn">)</span></p></li></ol></div><div class="SIntrapara">Explain why the expressions are values or not. <a href="i1-2.html#%28counter._%28exercise._ex~3adefine-struct-value%29%29" class="ex-end" data-pltdoc="x"></a></div></p><p><div class="SIntrapara"><a name="(counter._(exercise._ex~3adefine-struct2))"></a><span style="font-weight: bold">Exercise</span> 127. Suppose the program contains
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="hspace"> </span><span class="RktSym">ball</span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktSym">y</span><span class="hspace"> </span><span class="RktSym">speed-x</span><span class="hspace"> </span><span class="RktSym">speed-y</span><span class="RktPn">]</span><span class="RktPn">)</span></p></blockquote></div><div class="SIntrapara">Predict the results of evaluating the following expression:
|
||
|
|
</div><div class="SIntrapara"><ol><li><p><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._number~3f%29%29" class="RktValLink" data-pltdoc="x">number?</a></span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym">make-ball</span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">2</span><span class="stt"> </span><span class="RktVal">3</span><span class="stt"> </span><span class="RktVal">4</span><span class="RktPn">)</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym">ball-speed-y</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym">make-ball</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="stt"> </span><span class="RktVal">3</span><span class="stt"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktVal">2</span><span class="stt"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym">ball-y</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym">make-ball</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="stt"> </span><span class="RktVal">3</span><span class="stt"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktVal">2</span><span class="stt"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym">ball-x</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._make-posn%29%29" class="RktValLink" data-pltdoc="x">make-posn</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="RktPn">)</span></p></li><li><p><span class="RktPn">(</span><span class="RktSym">ball-speed-y</span><span class="stt"> </span><span class="RktVal">5</span><span class="RktPn">)</span></p></li></ol></div><div class="SIntrapara">Check your predictions in the interactions area and with the stepper. <a href="i1-2.html#%28counter._%28exercise._ex~3adefine-struct2%29%29" class="ex-end" data-pltdoc="x"></a></div></p><p><div class="SIntrapara"><a name="(idx._(gentag._193))"></a>
|
||
|
|
<a name="(idx._(gentag._194))"></a>
|
||
|
|
<a name="(idx._(gentag._195))"></a>
|
||
|
|
<a name="(idx._(gentag._196))"></a>
|
||
|
|
<a name="(idx._(gentag._197))"></a>
|
||
|
|
<a name="(idx._(gentag._198))"></a>
|
||
|
|
<a name="(idx._(gentag._199))"></a>
|
||
|
|
<a name="(idx._(gentag._200))"></a>
|
||
|
|
<a name="(idx._(gentag._201))"></a>
|
||
|
|
<a name="(idx._(gentag._202))"></a>
|
||
|
|
<a name="(idx._(gentag._203))"></a>
|
||
|
|
<a name="(idx._(gentag._204))"></a>
|
||
|
|
</div><div class="SIntrapara"><blockquote class="Figure"><blockquote class="Centerfigure"><blockquote class="FigureInside"><table cellspacing="0" cellpadding="0"><tr><td align="right" valign="baseline"><span class="hspace"> </span><span class="RktVar">def-expr</span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">=</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktVar">definition</span></td></tr><tr><td align="right" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">|</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktVar">expr</span></td></tr><tr><td align="right" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">|</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktVar">test-case</span></td></tr><tr><td align="right" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td></tr><tr><td align="right" valign="baseline"><span class="hspace"> </span><span class="RktVar">definition</span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">=</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktVar">name</span><span class="hspace"> </span><span class="RktVar">variable</span><span class="hspace"> </span><span class="RktVar">variable</span><span class="hspace"> </span><span class="RktSym">...</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVar">expr</span><span class="RktPn">)</span></td></tr><tr><td align="right" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">|</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktVar">name</span><span class="hspace"> </span><span class="RktVar">expr</span><span class="RktPn">)</span></td></tr><tr><td align="right" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="center" valign="baseline">|</td><td align="left" valign="baseline"><span class="stt"> </span></td><td align="left" valign="baseline"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="hspace"> </span><span class="RktVar">name</span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktVar">name</span><span class="hspace"> </span><span class="RktSym">...</span><span class="RktPn">]</span><span cla
|
||
|
|
number of testing forms.</p><p>The general meaning of testing expressions is easy to explain. When you
|
||
|
|
click the <span class="emph">RUN</span> button, DrRacket collects all testing expressions and
|
||
|
|
moves them to the end of the program, retaining the order in which they
|
||
|
|
appear. It then evaluates the content of the definitions area. Each test
|
||
|
|
evaluates its pieces and then compares them with the expected outcome via
|
||
|
|
some predicate. Beyond that, tests communicate with DrRacket to collect some
|
||
|
|
statistics and information on how to display test failures.</p><p><div class="SIntrapara">For details, read the documentation on these test forms. Here are some
|
||
|
|
illustrative examples:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._check-expect%29%29" class="RktStxLink" data-pltdoc="x">check-expect</a></span><span class="RktCmt"> compares the outcome and the expected value with </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._equal~3f%29%29" class="RktValLink" data-pltdoc="x">equal?</a></span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._check-expect%29%29" class="RktStxLink" data-pltdoc="x">check-expect</a></span><span class="hspace"> </span><span class="RktVal">3</span><span class="hspace"> </span><span class="RktVal">3</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span></td></tr><tr><td><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._check-member-of%29%29" class="RktStxLink" data-pltdoc="x">check-member-of</a></span><span class="RktCmt"> compares the outcome and the expected values with </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._equal~3f%29%29" class="RktValLink" data-pltdoc="x">equal?</a></span></td></tr><tr><td><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktCmt">if one of them yields </span><span class="RktVal">#true</span><span class="RktCmt">, the test succeeds</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._check-member-of%29%29" class="RktStxLink" data-pltdoc="x">check-member-of</a></span><span class="hspace"> </span><span class="RktVal">"green"</span><span class="hspace"> </span><span class="RktVal">"red"</span><span class="hspace"> </span><span class="RktVal">"yellow"</span><span class="hspace"> </span><span class="RktVal">"green"</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span></td></tr><tr><td><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._check-within%29%29" class="RktStxLink" data-pltdoc="x">check-within</a></span><span class="RktCmt"> compares the outcome and the expected value with a predicate</span></td></tr><tr><td><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktCmt"> like </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._equal~3f%29%29" class="RktValLink" data-pltdoc="x">equal?</a></span><span class="RktCmt"> but allows for a tolerance of </span><span class="RktSym">epsilon</span><span class="RktCmt"> for each inexact number </span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._check-within%29%29" class="RktStxLink" data-pltdoc="x">check-within</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._make-posn%29%29" class="RktValLink" data-pltdoc="x">make-posn</a></span><span class="hspace"> </span><span class="RktVal">#i1.0</span><span class="hspace"> </span><span class="Rk
|
||
|
|
re-introduce these test forms as needed.</div></p><p><div class="SIntrapara"><a name="(counter._(exercise._ex~3atest-fails))"></a><span style="font-weight: bold">Exercise</span> 128. Copy the following tests into DrRacket’s definitions area:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._check-member-of%29%29" class="RktStxLink" data-pltdoc="x">check-member-of</a></span><span class="hspace"> </span><span class="RktVal">"green"</span><span class="hspace"> </span><span class="RktVal">"red"</span><span class="hspace"> </span><span class="RktVal">"yellow"</span><span class="hspace"> </span><span class="RktVal">"grey"</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._check-within%29%29" class="RktStxLink" data-pltdoc="x">check-within</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._make-posn%29%29" class="RktValLink" data-pltdoc="x">make-posn</a></span><span class="hspace"> </span><span class="RktVal">#i1.0</span><span class="hspace"> </span><span class="RktVal">#i1.1</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._make-posn%29%29" class="RktValLink" data-pltdoc="x">make-posn</a></span><span class="hspace"> </span><span class="RktVal">#i0.9</span><span class="hspace"> </span><span class="RktVal">#i1.2</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">0.01</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._check-range%29%29" class="RktStxLink" data-pltdoc="x">check-range</a></span><span class="hspace"> </span><span class="RktVal">#i0.9</span><span class="hspace"> </span><span class="RktVal">#i0.6</span><span class="hspace"> </span><span class="RktVal">#i0.8</span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._check-random%29%29" class="RktStxLink" data-pltdoc="x">check-random</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._make-posn%29%29" class="RktValLink" data-pltdoc="x">make-posn</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._random%29%29" class="RktValLink" data-pltdoc="x">random</a></span><span class="hspace"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._random%29%29" class="RktValLink" data-pltdoc="x">random</a></span><span class="hspace"> </span><span class="RktVal">9</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner
|
||
|
|
developed BSL and its error reporting system specifically for novices
|
||
|
|
who, by definition, make mistakes, error messages need some getting used
|
||
|
|
to.</p><p><div class="SIntrapara">Below we sample the kinds of error messages that you may
|
||
|
|
encounter. Each entry in one of the listings consists of three parts:
|
||
|
|
</div><div class="SIntrapara"><ul><li><p>the code fragments that signal the error message;</p></li><li><p>the error message; and</p></li><li><p>an explanation with a suggestion on how to fix the mistake.</p></li></ul></div><div class="SIntrapara">Consider the following example, which is <span style="font-weight: bold">the worst possible error
|
||
|
|
message</span> you may ever see:
|
||
|
|
</div><div class="SIntrapara"><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">absolute</span><span class="hspace"> </span><span class="RktSym">n</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="highlighted"><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3c%29%29" class="RktValLink" data-pltdoc="x"><</a></span></span><span class="hspace"> </span><span class="RktVal">0</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._-%29%29" class="RktValLink" data-pltdoc="x"><span class="nobreak">-</span></a></span><span class="hspace"> </span><span class="RktSym">n</span><span class="RktPn">)</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._else%29%29" class="RktStxLink" data-pltdoc="x">else</a></span><span class="hspace"> </span><span class="RktSym">n</span><span class="RktPn">]</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="stt"><: expected a function call, but there is no open parenthesis before
|
||
|
|
this function</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>A <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span> expression consists of the keyword followed by an
|
||
|
|
arbitrarily long sequence of <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span> clauses. In turn, every clause
|
||
|
|
consists of two parts: a condition and an answer, both of which are
|
||
|
|
expressions. In this definition of <span class="RktSym">absolute</span>, the first clause
|
||
|
|
starts with <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3c%29%29" class="RktValLink" data-pltdoc="x"><</a></span>, which is supposed to be a condition but isn’t even
|
||
|
|
an expression according to our definition. This confuses BSL so much
|
||
|
|
that it does not “see” the open parenthesis to the left of <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3c%29%29" class="RktValLink" data-pltdoc="x"><</a></span>. The
|
||
|
|
fix is to use <span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3c%29%29" class="RktValLink" data-pltdoc="x"><</a></span><span class="stt"> </span><span class="RktSym">n</span><span class="stt"> </span><span class="RktVal">0</span><span class="RktPn">)</span> as the condition.</p></td></tr></table></div><div class="SIntrapara">The highlighting of <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3c%29%29" class="RktValLink" data-pltdoc="x"><</a></span> in the function definition points to the
|
||
|
|
error. Below the definition, you can see the error message that DrRacket
|
||
|
|
presents in the interactions window if you click <span class="emph">RUN</span>. Study the
|
||
|
|
explanation of the error on the right to understand how to address this
|
||
|
|
somewhat self-contradictory message. And now rest assured that no other
|
||
|
|
error message is even remotely as opaque as this one.</div></p><p>So, when an error shows up and you need help, find the appropriate figure,
|
||
|
|
search the entries for a match, and then study the complete entry.</p><p><span class="emph">Error Messages about Function Applications in BSL</span></p><p><div class="SIntrapara">Assume that the definitions area contains the following and nothing else:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktCmt">;</span><span class="RktCmt"> </span><a href="part_one.html#%28tech._number%29" class="techoutside" data-pltdoc="x"><span class="techinside">Number</span></a><span class="RktCmt"> </span><a href="part_one.html#%28tech._number%29" class="techoutside" data-pltdoc="x"><span class="techinside">Number</span></a><span class="RktCmt"> -> </span><a href="part_one.html#%28tech._number%29" class="techoutside" data-pltdoc="x"><span class="techinside">Number</span></a></td></tr><tr><td><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktCmt">finds the average of </span><span class="RktSym">x</span><span class="RktCmt"> and </span><span class="RktSym">y</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">average</span><span class="hspace"> </span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktSym">y</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2F%29%29" class="RktValLink" data-pltdoc="x">/</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktSym">y</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">Hit the <span class="emph">RUN</span> button. Now you may encounter the error
|
||
|
|
messages below.</div></p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><span class="RktPn">(</span><span class="highlighted"><span class="RktSym">f</span></span><span class="hspace"> </span><span class="RktVal">1</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="stt">f: this function is not defined</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>The application names <span class="RktSym">f</span> as the function,
|
||
|
|
and <span class="RktSym">f</span> is not defined in the definitions area.
|
||
|
|
Define the function, or make sure that the variable
|
||
|
|
name is spelled correctly.</p></td></tr></table></p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><span class="RktPn">(</span><span class="highlighted"><span class="RktVal">1</span></span><span class="hspace"> </span><span class="RktVal">3</span><span class="hspace"> </span><span class="RktVal">"three"</span><span class="hspace"> </span><span class="RktVal">#true</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="stt">function call: expected a function after the
|
||
|
|
open parenthesis, but found a number</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>An open parenthesis must always be followed by a keyword or the name
|
||
|
|
of a function, and <span class="RktVal">1</span> is neither. A function name is either
|
||
|
|
defined by BSL, say <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span>, or in the definitions area, say
|
||
|
|
<span class="RktSym">average</span>.</p></td></tr></table></p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><span class="highlighted"><span class="RktPn">(</span><span class="RktSym">average</span><span class="stt"> </span><span class="RktVal">7</span><span class="RktPn">)</span></span></td></tr><tr><td><p><span class="stt">average: expects 2 arguments, but found only 1</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>This function call applies <span class="RktSym">average</span> to
|
||
|
|
one argument, <span class="RktVal">7</span>, even though its definition
|
||
|
|
calls for two numbers.</p></td></tr></table></p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><span class="highlighted"><span class="RktPn">(</span><span class="RktSym">average</span><span class="stt"> </span><span class="RktVal">1</span><span class="stt"> </span><span class="RktVal">2</span><span class="stt"> </span><span class="RktVal">3</span><span class="RktPn">)</span></span></td></tr><tr><td><p><span class="stt">average: expects 2 arguments, but found 3</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>Here <span class="RktSym">average</span> is applied to <span style="font-weight: bold">three</span> numbers instead of two.</p></td></tr></table></p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><span class="highlighted"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._make-posn%29%29" class="RktValLink" data-pltdoc="x">make-posn</a></span><span class="stt"> </span><span class="RktVal">1</span><span class="RktPn">)</span></span></td></tr><tr><td><p><span class="stt">make-posn: expects 2 arguments, but found only 1</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>Functions defined by BSL must also be applied to the correct number
|
||
|
|
of arguments. For example, <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._make-posn%29%29" class="RktValLink" data-pltdoc="x">make-posn</a></span> must be applied to two arguments.</p></td></tr></table></p><p><span class="emph">Error Messages about Wrong Data in BSL</span></p><p><div class="SIntrapara">The error scenarios below again assume that the definitions area contains
|
||
|
|
the following:
|
||
|
|
</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktCmt">;</span><span class="RktCmt"> </span><a href="part_one.html#%28tech._number%29" class="techoutside" data-pltdoc="x"><span class="techinside">Number</span></a><span class="RktCmt"> </span><a href="part_one.html#%28tech._number%29" class="techoutside" data-pltdoc="x"><span class="techinside">Number</span></a><span class="RktCmt"> -> </span><a href="part_one.html#%28tech._number%29" class="techoutside" data-pltdoc="x"><span class="techinside">Number</span></a></td></tr><tr><td><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktCmt">find the average of </span><span class="RktSym">x</span><span class="RktCmt"> and </span><span class="RktSym">y</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">average</span><span class="hspace"> </span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktSym">y</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">Remember that <span class="RktSym">posn</span> is a pre-defined structure type.</div></p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._posn-x%29%29" class="RktValLink" data-pltdoc="x">posn-x</a></span><span class="hspace"> </span><span class="RktVal">#true</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="stt">posn-x: expects a posn, given #true</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>A function must be applied to the arguments it expects. For
|
||
|
|
example, <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._posn-x%29%29" class="RktValLink" data-pltdoc="x">posn-x</a></span> expects an instance of <span class="RktSym">posn</span>.</p></td></tr></table></p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><span class="RktPn">(</span><span class="RktSym">average</span><span class="hspace"> </span><span class="RktVal">"one"</span><span class="hspace"> </span><span class="RktVal">"two"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="stt">+: expects a number as 1st argument, given "one"</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>A function defined to consume two
|
||
|
|
<a href="part_one.html#%28tech._number%29" class="techoutside" data-pltdoc="x"><span class="techinside">Number</span></a>s must be applied to two
|
||
|
|
<a href="part_one.html#%28tech._number%29" class="techoutside" data-pltdoc="x"><span class="techinside">Number</span></a>s; here <span class="RktSym">average</span> is applied to
|
||
|
|
<a href="part_one.html#%28tech._string%29" class="techoutside" data-pltdoc="x"><span class="techinside">String</span></a>s. The error message is triggered only
|
||
|
|
when <span class="RktSym">average</span> applies <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span> to these
|
||
|
|
<a href="part_one.html#%28tech._string%29" class="techoutside" data-pltdoc="x"><span class="techinside">String</span></a>s. Like all primitive operations,
|
||
|
|
<span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span> is a checked function.</p></td></tr></table></p><p><span class="emph">Error Messages about Conditionals in BSL</span></p><p><div class="SIntrapara">This time we expect a constant definition in the definitions area:
|
||
|
|
</div><div class="SIntrapara"><table cellspacing="0" cellpadding="0" class="terror"><tr><td><blockquote class="SubFlow"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktCmt">;</span><span class="RktCmt"> </span><a href="part_two.html#%28tech._n%29" class="techoutside" data-pltdoc="x"><span class="techinside">N</span></a><span class="RktCmt"> in [</span><span class="RktVal">0</span><span class="RktCmt">,</span><span class="RktVal">1</span><span class="RktCmt">,...</span><span class="RktVal">10</span><span class="RktCmt">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">0-to-9</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._random%29%29" class="RktValLink" data-pltdoc="x">random</a></span><span class="hspace"> </span><span class="RktVal">10</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></blockquote></blockquote></td></tr></table></div></p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="highlighted"><span class="RktPn">[</span><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3e~3d%29%29" class="RktValLink" data-pltdoc="x">>=</a></span><span class="stt"> </span><span class="RktSym">0-to-9</span><span class="stt"> </span><span class="RktVal">5</span><span class="RktPn">)</span><span class="RktPn">]</span></span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="stt">cond: expected a clause with a question and an answer, but
|
||
|
|
found a clause with only one part</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>Every <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span> clause must consist of exactly two parts: a
|
||
|
|
condition and an answer. Here <span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3e~3d%29%29" class="RktValLink" data-pltdoc="x">>=</a></span><span class="stt"> </span><span class="RktSym">0-to-9</span><span class="stt"> </span><span class="RktVal">5</span><span class="RktPn">)</span> is apparently
|
||
|
|
intended as the condition; the answer is missing.</p></td></tr></table></p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="highlighted"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3e~3d%29%29" class="RktValLink" data-pltdoc="x">>=</a></span><span class="stt"> </span><span class="RktSym">0-to-9</span><span class="stt"> </span><span class="RktVal">5</span><span class="RktPn">)</span></span></td></tr><tr><td><span class="hspace"> </span><span class="highlighted"><span class="RktVal">"head"</span></span></td></tr><tr><td><span class="hspace"> </span><span class="highlighted"><span class="RktVal">"tail"</span></span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="stt">cond: expected a clause with a question and an answer,
|
||
|
|
but found a clause with 3 parts</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>In this case, the <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span> clause consists of three parts,
|
||
|
|
which also violates the grammar. While <span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28def._htdp-beginner._%28%28lib._lang%2Fhtdp-beginner..rkt%29._~3e~3d%29%29" class="RktValLink" data-pltdoc="x">>=</a></span><span class="stt"> </span><span class="RktSym">0-to-9</span><span class="stt"> </span><span class="RktVal">5</span><span class="RktPn">)</span> is clearly
|
||
|
|
intended to be the condition, the clause comes with two
|
||
|
|
answers: <span class="RktVal">"head"</span> and <span class="RktVal">"tail"</span>. Pick one or create a single
|
||
|
|
value from the two strings.</p></td></tr></table></p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><span class="highlighted"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span><span class="RktPn">)</span></span></td></tr><tr><td><p><span class="stt">cond: expected a clause after cond, but nothing</span><span class="stt">’</span><span class="stt">s there</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>A conditional must come with at least one <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._cond%29%29" class="RktStxLink" data-pltdoc="x">cond</a></span> clause and
|
||
|
|
usually it comes with at least two.</p></td></tr></table></p><p><span class="emph">Error Messages about Function Definitions in BSL</span></p><p>All of the following error scenarios assume that you have placed the code
|
||
|
|
snippet into the definitions area and hit <span class="emph">RUN</span>.</p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">f</span><span class="RktPn">(</span><span class="RktSym">x</span><span class="RktPn">)</span><span class="hspace"> </span><span class="highlighted"><span class="RktSym">x</span></span><span class="RktPn">)</span></td></tr><tr><td><p><span class="stt">define: expected only one expression after the
|
||
|
|
variable name f, but found 1 extra part</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>A definition consist of three parts: the
|
||
|
|
<span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span> keyword, a sequence of variable names
|
||
|
|
enclosed in parentheses, and an expression. This
|
||
|
|
definition consists of four parts; this definition is
|
||
|
|
an attempt to use the standard notation from algebra
|
||
|
|
courses for the header <span class="RktSym">f</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym">x</span><span class="RktPn">)</span> instead of
|
||
|
|
<span class="RktPn">(</span><span class="RktSym">f</span><span class="stt"> </span><span class="RktSym">x</span><span class="RktPn">)</span>.</p></td></tr></table></p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktSym">x</span><span class="hspace"> </span><span class="highlighted"><span class="RktSym">x</span></span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="stt">define: found a variable that is used more than once: x</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>The sequence of parameters in a function
|
||
|
|
definition must not contain duplicate variables.</p></td></tr></table></p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="highlighted"><span class="RktPn">(</span><span class="RktSym">g</span><span class="RktPn">)</span></span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="stt">define: expected at least one variable after
|
||
|
|
the function name, but found none</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>In BSL a function header must contain at
|
||
|
|
least two names. The first one is the name of the
|
||
|
|
function; the remaining variable names are the
|
||
|
|
parameters, and they are missing here.</p></td></tr></table></p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktPn">(</span><span class="highlighted"><span class="RktSym">x</span></span><span class="RktPn">)</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="stt">define: expected a variable, but found a part</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>The function header contains
|
||
|
|
<span class="RktPn">(</span><span class="RktSym">x</span><span class="RktPn">)</span>, which is <span style="font-weight: bold">not</span> a variable name.</p></td></tr></table></p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">h</span><span class="hspace"> </span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktSym">y</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">x</span><span class="hspace"> </span><span class="highlighted"><span class="RktSym">y</span></span><span class="RktPn">)</span></td></tr><tr><td><p><span class="stt">define: expected only one expression for the function
|
||
|
|
body, but found 1 extra part</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>This function definition comes with two
|
||
|
|
expressions following the header: <span class="RktSym">x</span> and <span class="RktSym">y</span>.</p></td></tr></table></p><p><span class="emph">Error Messages about Structure Type Definitions in BSL</span></p><p>Now you need to place the structure type definitions into the definitions
|
||
|
|
area and hit <span class="emph">RUN</span> to experiment with the following errors.</p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="hspace"> </span><span class="highlighted"><span class="RktPn">[</span><span class="RktSym">x</span><span class="RktPn">]</span></span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="hspace"> </span><span class="highlighted"><span class="RktPn">[</span><span class="RktSym">x</span><span class="stt"> </span><span class="RktSym">y</span><span class="RktPn">]</span></span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="stt">define-struct: expected the structure name after
|
||
|
|
define-struct, but found a part</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>A structure type definition consists of three
|
||
|
|
parts: the <span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span> keyword, the
|
||
|
|
structure’s name,
|
||
|
|
and a sequence of names in
|
||
|
|
parentheses. Here the structure’s name is missing.</p></td></tr></table></p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="hspace"> </span><span class="RktSym">x</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">y</span><span class="hspace"> </span><span class="highlighted"><span class="RktSym">y</span></span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="stt">define-struct: found a field name that is used more than once: y</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>The sequence of field names in a structure
|
||
|
|
type definition must not contain duplicate names.</p></td></tr></table></p><p><table cellspacing="0" cellpadding="0" class="boxed"><tr><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><table cellspacing="0" cellpadding="0" style="border-collapse: collapse;"><tr><td style="border-bottom: 1px solid black;"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="hspace"> </span><span class="RktSym">x</span><span class="hspace"> </span><span class="highlighted"><span class="RktSym">y</span></span><span class="RktPn">)</span></td></tr><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="https://docs.racket-lang.org/htdp-langs/beginner.html#%28form._%28%28lib._lang%2Fhtdp-beginner..rkt%29._define-struct%29%29" class="RktStxLink" data-pltdoc="x">define-struct</a></span><span class="hspace"> </span><span class="RktSym">x</span><span class="hspace"> </span><span class="highlighted"><span class="RktSym">y</span></span><span class="hspace"> </span><span class="RktSym">z</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="stt">define-struct: expected at least one field name
|
||
|
|
(in parentheses) after the structure name, but
|
||
|
|
found something else</span></p></td></tr></table></td><td valign="top" align="left" valign="top" width="250" style="padding:0 0px 0 15px"><p>These structure type definitions lack the
|
||
|
|
sequence of field names, enclosed in parentheses.</p></td></tr></table></p><div class="navsetbottom"><span class="navleft"><div class="nosearchform"></div> <span class="tocsettoggle"> <a href="javascript:void(0);" title="show/hide table of contents" onclick="TocsetToggle();">contents</a></span></span><span class="navright"> <a href="part_one.html" title="backward to "I Fixed-Size Data"" data-pltdoc="x">← prev</a> <a href="index.html" title="up to "How to Design Programs, Second Edition"" data-pltdoc="x">up</a> <a href="part_two.html" title="forward to "II Arbitrarily Large Data"" data-pltdoc="x">next →</a></span> </div></div></div><div id="contextindicator"> </div><script data-cfasync="false" src="../../cdn-cgi/scripts/5c5dd728/cloudflare-static/email-decode.min.js"></script></body></html>
|