Signed-off-by: Jim Pryor <profjim@jimpryor.net>
at-issue value of the sentence in which they occur. What this claim
says is unpacked at some length here: <http://tinyurl.com/cbarker/salt/interaction/salt.pdf>.
at-issue value of the sentence in which they occur. What this claim
says is unpacked at some length here: <http://tinyurl.com/cbarker/salt/interaction/salt.pdf>.
-<!--
-Chris also emailed me this paper, may this be publicly posted?
-<http://tinyurl.com/cbarker/salt/interaction/salt.pdf>
--->
-
-
In brief, "The man read the damn book" means the same thing as "The
man read the book" as far as what must be the case in the world for
the sentence to be true. However, the sentence with the "damn" in it
In brief, "The man read the damn book" means the same thing as "The
man read the book" as far as what must be the case in the world for
the sentence to be true. However, the sentence with the "damn" in it
shouldn't be burdened with helping compute affective content.
shouldn't be burdened with helping compute affective content.
-Some nice things: we can remove one or both of the damns, or add more,
-and everything works. As desired, the rest of the words don't need to
-know anything about side effects.
-
-Some of the complexities:
-
-Because the compositional semantics doesn't know about words that
-denote functions, "damn" contributes a trivial adjectival meaning
-(here, the identity function 'id) to the composition.
-
-
What we did in Monday's seminar:
What we did in Monday's seminar:
-; evaluates to ((the . man) . (read . (the . book)))
+That evaluates to nested structure of pairs, that Scheme displays as:
+
+ ((the . man) . (read . (the . book)))
`(cons M N)` is a request to build an ordered pair out of the values M and N.
Scheme displays that pair as `(M . N)` You can't write the pair that way yourself:
if you tried to, Scheme would think you're trying to apply the function M to some arguments, which you're not, and also
Scheme would be confused by what argument the `.` is supposed to be. So, you say:
`(cons M N)` is a request to build an ordered pair out of the values M and N.
Scheme displays that pair as `(M . N)` You can't write the pair that way yourself:
if you tried to, Scheme would think you're trying to apply the function M to some arguments, which you're not, and also
Scheme would be confused by what argument the `.` is supposed to be. So, you say:
and that evaluates to an ordered pair, and Scheme displays that ordered pair as
and that evaluates to an ordered pair, and Scheme displays that ordered pair as
There is an underlying reason why parentheses are used both when displaying the ordered pair, and also to mean "apply this function to these arguments." However, at this point, you may well see this as a confusing overloading of parentheses to fill different syntactic roles.
There is an underlying reason why parentheses are used both when displaying the ordered pair, and also to mean "apply this function to these arguments." However, at this point, you may well see this as a confusing overloading of parentheses to fill different syntactic roles.
-Now what about the elements of our ordered pairs. Why do we say `(cons 'the 'man)`. Why are those single quotes there? Well, if you just said `(cons the man)`, Scheme would understand `the` and `man` to be variables, and it would complain that you hadn't bound these variables to any values. We don't want to build an ordered pair out of the values possessed by variables `the` and `man`. Instead, we want to just make up some dummy value THE to stand for the meaning of an object-language determiner, and some dummy value MAN to stand for the meaning of an object-language noun phrase. The notation `'the` is Scheme's way of representing a dummy, atomic value. Note there is no closing single quote, only a prefixed one. Scheme calls these dummy atomic values "symbols." That term is a bit misleading, because the symbol `'the` is not the same as the variable `the`. Neither is it the same as what's called the string `"the"`. The latter is a structured value, composed out of three character values. The symbol `'the`, on the other hand, is an atomic value. It has no parts. (The notation the programmer uses to designate this atomic value has four characters, but the value itself has no parts.) If you think this is all somewhat confusing, you're right. It gets easier with practice.
+Now what about the elements of our ordered pairs. Why do we say `(cons 'the 'man)`. Why are those single quotes there? Well, if you just said `(cons the man)`, Scheme would understand `the` and `man` to be variables, and it would complain that you hadn't bound these variables to any values. We don't want to build an ordered pair out of the values possessed by variables `the` and `man`. Instead, we want to just make up some dummy value THE to stand for the meaning of an object-language determiner, and some dummy value MAN to stand for the meaning of an object-language noun phrase. The notation `'the` is Scheme's way of representing a dummy, atomic value. Note there is no closing single quote, only a prefixed one. Scheme calls these dummy atomic values "symbols." That term is a bit misleading, because the symbol `'the` is not the same as the variable `the`. Neither is it the same as what's called the string `"the"`. The latter is a structured value, composed out of three character values. The symbol `'the`, on the other hand, is an atomic value. It has no parts. (The notation the programmer uses to designate this atomic value has four characters, but the value designated itself has no parts.) If you think this is all somewhat confusing, you're right. It gets easier with practice.
-`'the` can also be written `(quote the)`. This is even more confusing, because here the `the` is not interpreted as a variable. (Try `(let* ((the 3)) (quote the))`.) If you come across this, just read `(quote the)` as a verbose (and perhaps misleading) way of writing 'the, not as the application of any function to any value.
+`'the` can also be written `(quote the)`. This is even more confusing, because here the `the` is not interpreted as a variable. (Try `(let* ((the 3)) (quote the))`.) If you come across this, just read `(quote the)` as a verbose (and perhaps misleading) way of writing `'the`, not as the application of any function to any value.
Okay, so what we've done is just create a bunch of new atomic values `'the`, `'man`, and so on. Scheme doesn't know how to do much with these. It knows for instance that `'the` is the same value as `'the` and a different value than `'man`. But it doesn't know much more than that. That's all we need or want here.
Okay, so what we've done is just create a bunch of new atomic values `'the`, `'man`, and so on. Scheme doesn't know how to do much with these. It knows for instance that `'the` is the same value as `'the` and a different value than `'man`. But it doesn't know much more than that. That's all we need or want here.
and that we can think of as the tree:
;
and that we can think of as the tree:
;
- /----------------\
- / \
- / \
- / \
- / \
- / \ / \
- / \ / \
- / \ / \
- / \ / \
-meaning of meaning of meaning of \
- "the" "man" "read" / \
- / \
- / \
- / \
- meaning of meaning of
- "the" "book"
+ /----------------\
+ / \
+ / \
+ / \
+ / \
+ / \ / \
+ / \ / \
+ / \ / \
+ / \ / \
+ meaning of meaning of meaning of \
+ "the" "man" "read" / \
+ / \
+ / \
+ / \
+ meaning of meaning of
+ "the" "book"
Okay, let's get back to "damn."
Okay, let's get back to "damn."