damn.mdwn

   1 Expressives such as "damn" have side effects that don't affect the
   2 at-issue value of the sentence in which they occur.  What this claim
   3 says is unpacked at some length here: <http://tinyurl.com/cbarker/salt/interaction/salt.pdf>.
   4
   5 In brief, "The man read the damn book" means the same thing as "The
   6 man read the book" as far as what must be the case in the world for
   7 the sentence to be true.  However, the sentence with the "damn" in it
   8 in addition conveys the claim that something about the described
   9 situtation is not as it should be.  (The person who is committed to
  10 that claim is whoever utters the sentence.)
  11
  12 So we need a way of evaluating sentences that allows "damn" to launch
  13 a side effect without affecting the truth conditions of the sentence
  14 in which it occurs.
  15
  16 Furthermore, we don't want to change the meaning of "the", "man",
  17 "read", or "book"---those elements are completely innocent, and
  18 shouldn't be burdened with helping compute affective content.
  19
  20
  21
  22 What we did in Monday's seminar:
  23
  24 We start with a simulation of semantic composition:
  25
  26         (cons (cons 'the 'man)
  27                   (cons 'read
  28                                 (cons 'the
  29                                           'book)))
  30
  31 That evaluates to nested structure of pairs, that Scheme displays as:
  32
  33         '((the . man) . (read . (the . book)))
  34
  35 If you try it yourself, you may see instead:
  36
  37         '((the . man) read the . book)
  38
  39 This is shorthand for the same thing. Just trust me on that.
  40
  41 What's going on here?
  42
  43 `(cons M N)` is a request to build an ordered pair out of the values M and N.
  44 Scheme displays that pair as `'(M . N)` You can't write `(M . N)` yourself and expect Scheme to understand that you're talking about this pair. If you tried, to, Scheme would think you're trying to apply the function M to some arguments, which you're not, and also
  45 Scheme would be confused by what argument the `.` is supposed to be. So, you say:
  46
  47         (cons M N)
  48
  49 and that evaluates to an ordered pair, and Scheme displays that ordered pair as
  50
  51         '(M . N)
  52
  53 You *can* write `'(M . N)` (with the prefixed single quote), and Scheme will understand you then. However, we're going to be using that same single quote prefix to do something else in a moment, and I don't want now to explain how these uses are related. So we'll write out `(cons M N)` longhand, and we'll leave the `'(M . N)` notation to Scheme for displaying the pair we built.
  54
  55 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.
  56
  57 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 primitive value THE to stand for the meaning of an object-language determiner, and some primitive value MAN to stand for the meaning of an object-language noun phrase. The notation `'the` is Scheme's way of designating a primitive atomic value. Note there is no closing single quote, only a prefixed one. Scheme calls these primitive 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.
  58
  59 `'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 `(quote the)`, just read it as a verbose (and perhaps misleading) way of writing `'the`, not as the application of any function to any value.
  60
  61 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.
  62
  63 And we built a tree out of those values, representing the tree by a nested structure of pairs of leaf-labels.
  64
  65 The program we submitted to Scheme:
  66
  67         (cons (cons 'the 'man)
  68                   (cons 'read
  69                                 (cons 'the
  70                                           'book)))
  71
  72 evaluates to the nested structure of pairs that Scheme displays as:
  73
  74         '((the . man) . (read . (the . book)))
  75
  76 Although there aren't `'`s prefixed to each of the elements of this nested structure, those elements are still the `'the`, `'man` and so on primitive atomic values that we specified. Not the values (if any) possessed by some variables `the`, `man`, and so on.
  77
  78 We can think of this nested structure of pairs as the tree:
  79
  80                                  /----------------\
  81                                 /                  \
  82                            /                    \
  83                           /                      \
  84                          /                        \
  85                         / \                      / \
  86                    /   \                    /   \
  87                   /     \                  /     \
  88                  /       \                /       \
  89         meaning of   meaning of   meaning of   \
  90           "the"        "man"       "read"      / \
  91                                                                                   /   \
  92                                                                                  /     \
  93                                                                                 /       \
  94                                                                         meaning of  meaning of
  95                                                                           "the"      "book"
  96
  97 Okay, let's get back to "damn."
  98
  99 We start by defining `damn` as a "thunk" that when applied to zero arguments returns a trivial adjectival meaning, which we'll designate with the primitive symbol `'id`.
 100
 101 What's a "thunk"?
 102
 103 Remember, in Scheme you can have functions that take one value, and also functions that take two values, and also functions that take zero values. The last ones are called "thunks." The thunk is not identical to the value it returns. For instance:
 104
 105         (lambda () 3)
 106
 107 is a thunk that returns the integer 3. If we bind the variable `t` to that thunk, then `t` is a function (Scheme will display it as`#<procedure>`)
 108 not an integer. Whereas `(t)` is an integer not a function.
 109
 110 There's no reason yet on hand for us to make `damn` be a thunk. For present purposes, we could also just define `damn` to be the symbol `'id`. But what we're going to go on to do does require us to make `damn` be a thunk. The reason for that is to postpone the evaluation of some expressions until the continuations we want to operate on are in place.
 111
 112 So for uniformity we're going to make `damn` be a thunk right from the beginning.
 113
 114 As we said, `damn` starts as a thunk that returns a trivial adjectival meaning `'id`:
 115
 116         (define damn (lambda () 'id))
 117
 118 Now we can say:
 119
 120         (cons (cons 'the 'man)
 121                   (cons 'read
 122                                 (cons 'the
 123                                           (cons (damn)
 124                                                 'book))))
 125
 126 and we get back:
 127
 128         ((the . man) . (read . (the . (id . book))))
 129
 130 If you try this yourself, you may see instead:
 131
 132         '((the . man) read the id . book)
 133
 134
 135
 136 Now we want to get some affective meaning into damn. So we might try:
 137
 138
 139         (define damn (lambda () 'bad))
 140
 141 But then:
 142
 143         (cons (cons 'the 'man)
 144                   (cons 'read
 145                                 (cons 'the
 146                                           (cons (damn)
 147                                                 'book))))
 148
 149 gives us:
 150
 151         ((the . man) . (read . (the . (bad . book))))
 152
 153 Which is not quite what we're looking for. We don't want to contribute the normal adjectival meaning of "bad" to the proposition asserted. Instead we want badness to be a side-issue linguistic contribution. We might try:
 154
 155         (define damn (lambda () (cons 'side-effect 'bad)))
 156
 157 But then we'd get:
 158
 159         ((the . man) . (read . (the . ((side-effect . bad) . book))))
 160
 161 and we said at the outset that the context `(the . ( ... . book))` shouldn't need to know how to interact with affective meanings. That's precisely the problem we're trying to solve.
 162
 163
 164 A promising way to handle this is with **continuations**, which you will get much more familiar with as this seminar progresses. Don't worry about not understanding what's going on quite yet. This is just an advertisement that's supposed to provoke your imagination.
 165
 166 Chris and others have applied the apparatus of continuations to the analysis of expressives in the paper cited at the top. For a simple in-class demonstration, we tried to do the following.
 167
 168         (call/cc (lambda k ...))
 169
 170 is Scheme's way of saying:
 171
 172 >       bind the continuation of this complex expression to `k` and evaluate the `...`
 173
 174
 175 So now we define `damn` like this:
 176
 177         (define damn (lambda () (call/cc (lambda (k) (print "bad") (k 'id)))))
 178
 179 In other words, `damn` is a thunk. When that thunk is evaluated (`(damn)`), we capture the pending future of the computation and bind that to `k`. Then we print "bad" and supply the argument `'id` to `k`. This last step means we go on evaluating the pending future contribution as if `(damn)` had simply returned `'id`.
 180
 181 What happens then when we evaluate:
 182
 183         (cons (cons 'the 'man)
 184                   (cons 'read
 185                                 (cons 'the
 186                                           (cons (damn)
 187                                                 'book))))
 188
 189 We get something like this:
 190
 191 <blockquote>
 192 <bold>"bad"</bad> ((the . man) . (read . (the . (id . book))))
 193 </blockquote>
 194
 195 Yay! The affective meaning has jumped out of the compositional evaluation of the main sentence, and the context `(the . (... . book))` only has to deal with the trivial adjectival meaning `'id`.
 196
 197 **But.** As came out in discussion, the `print` we're using here already constitutes a kind of side-effect mechanism of its own. If you say:
 198
 199         (define three-thunk (lambda () (print "hi") 3))
 200
 201 and then ask for the evaluation of:
 202
 203         (+ 2 (three-thunk))
 204
 205 you'll see something like:
 206
 207 <blockquote>
 208 <bold>"hi"</bad> 5
 209 </blockquote>
 210
 211 So the demonstration we tried in class was pedagogically flawed. It didn't properly display how continuations are a minimally effective apparatus for representing affective meaning. In fact, continuations were still doing the work, but it wasn't the explicit continuations we were writing out for you. It was instead continuations implicit in the `print` operation.
 212
 213 So a better demonstration would do without any device like `print` that already incorporates continuations implicitly. Any continuation-manipulation should be fully explicit.
 214
 215 Instead of representing the side-issue affective contribution by printing "bad", let's instead try to build a pair of side-effect contributions and at-issue assertion. Then what we want would be something like:
 216
 217         ((side-effect . bad) . ((the . man) . (read . (the . (id . book)))))
 218
 219 Only we want to get this from the evaluation of:
 220
 221         (cons (cons 'the 'man)
 222                   (cons 'read
 223                                 (cons 'the
 224                                           (cons (damn)
 225                                                 'book))))
 226
 227 where `(damn)` doesn't have widest scope. And we don't want to have to recruit all the other semantic material into accepting and passing along a possible affective argument.
 228
 229 How to do this?
 230
 231 It's not immediately clear how to do it with "undelimited" continuations, of the sort captured by `call/cc`. This is the natural first thing to try:
 232
 233
 234         (define damn (lambda () (call/cc (lambda (k) (cons (cons 'side-effect 'bad) (k 'id))))))
 235
 236
 237 The idea here is we capture the continuation that the thunk `(damn)` has when it gets evaluated. This continuation is bound to the variable `k`. We supply `'id` as an argument to that continuation. When the main, at-issue tree is all built, then we return a pair `((side-effect bad) AT-ISSUE-TREE)`.
 238
 239 However, this doesn't work. The reason is that an undelimited continuation represents the future of the evaluation of `(damn)` *until the end of the computation*. So when `'id` is supplied to `k`, we go back to building the at-issue tree until we're finished *and that's the end of the computation*. We never get to go back and evaluate the context `(cons (cons 'side-effect 'bad) ...)`.
 240
 241 The straightforward way to fix this is to use, not undelimited continuations, but instead a more powerful apparatus called "delimited continuations." These too will be explained in due course, don't expect to understand all this now.
 242
 243 A delimited continuation is captured not by using `call/cc`, but instead by using a variety of other operators. We'll use the operator `shift`. This substitutes for `call/cc`. The syntax in Scheme is slightly different. Whereas we wrote:
 244
 245         (call/cc (lambda k ...))
 246
 247 we instead write:
 248
 249         (shift k ...)
 250
 251 but the behavior is the same. It's just that now our continuation doesn't stretch until the end of the computation, but only up to some specified limit. The limit of the continuation is specified using the syntax:
 252
 253         (reset ...)
 254
 255 This is a kind of continuation-scope-marker. There are some interesting default behaviors if you don't explicitly specify where the limits are. But we'll be fully explicit here.
 256
 257 If a block `...` never invokes a shift, then `(reset ...)` will evaluate just the same as `...`. So for uniformity, we can designate our continuation-scopes even on computations that don't capture and manipulate continuations.
 258
 259 Going back to the beginning, then. We start with:
 260
 261         (define damn (lambda () 'id))
 262
 263 We evaluate:
 264
 265         (reset (cons (cons 'the 'man)
 266                   (cons 'read
 267                                 (cons 'the
 268                                           (cons (damn)
 269                                                 'book)))))
 270
 271 Remember, the reset isn't actually *doing* anything. It's not a function that's taking the other material as an argument. It's instead a scope-marker. Here it's not even needed (and in fact in the interactive interpreter, it wouldn't even be needed when we invoke continuations, because of the default position it takes).  But we're inserting it to be explicit and uniform.
 272
 273 Evaluating that gives us:
 274
 275         ((the . man) . (read . (the . (id . book))))
 276
 277
 278 Now to pair that with an affective side-issue content, we'd instead define `damn` as:
 279
 280         (require racket/control) ; this tells Scheme to let us use shift and reset
 281         (define damn (lambda () (shift k (cons (cons 'side-effect 'bad) (k 'id)))))
 282
 283 And voila:
 284
 285 (reset (cons (cons 'the 'man)
 286       (cons 'read
 287             (cons 'the
 288                   (cons (damn)
 289                         'book)))))
 290
 291 evaluates to:
 292
 293         ((side-effect bad) ((the . man) . (read . (the . (id . book)))))
 294
 295 So that's the straightforward way of repairing the strategy we used in class, without using `print`. We also have to switch to using delimited continuations.
 296
 297
 298 Ken Shan, however, pointed out a lovely way to get to the same end-point still using only undelimited continuations (`call/cc`).
 299
 300 (let ((pragma
 301        ; An ordered pair whose first component is the assertion
 302        ; operator, a unary function, and whose second component
 303        ; is the meaning of "damn", a thunk.
 304        (call/cc (lambda (k)
 305           (cons (lambda (p) p)
 306                 (lambda () (k (cons (lambda (p) (cons (cons 'side-effect 'bad) p))
 307                                     (lambda () 'id)))))))))
 308   (let ((assert (car pragma)) ; this binds assert to the first element of the pair pragma
 309         (damn   (cdr pragma))) ; this binds damn to the second element of the pair pragma
 310     (assert (cons (cons 'the 'student) (cons 'read (cons 'the (cons (damn) 'book)))))))
 311
 312 We won't do much to explain this. We'll just leave it for you to chew on.
 313
 314
 315
 316
 317         #lang racket
 318         ;(define damn (lambda () 'id))
 319         (define damn (lambda () (call/cc (lambda (k)
 320                                                                           ; (k 'id)
 321                                                                            (print "Something's bad")
 322                                                                            (k 'id)
 323                                                                            ))))
 324
 325         (list (list 'the (list (damn) 'man))
 326                   (list 'read
 327                                 (list 'the (list (damn) 'book))))
 328
 329
 330
 331
 332
 333         #lang racket
 334         (require racket/control)
 335
 336         (define damn0 (lambda ()
 337                                         'id))
 338
 339         (define damn1 (lambda ()
 340                                         (cons '("side effect" bad)
 341                                                   'id)))
 342
 343         (define damn2 (lambda () (shift k
 344                                                                         (cons '("side effect" bad)
 345                                                                                   (list (k 'id))))))
 346
 347         (define damn3 (lambda () (shift k
 348                                                                         (list (k 'id)
 349                                                                                   '("side effect" bad)))))
 350
 351
 352 ; Now if we use damn0, our compositional semantics will work OK but
 353 ; we don't yet have any affective contribution:
 354
 355         (list "main content" 'i (list 'like (list 'the (damn0) 'boy)))
 356         ; '("main content" i (like (the id boy)))
 357
 358
 359 ; If we use damn1, we've added in the affective side effect:
 360
 361         (list "main content" 'i (list 'like (list 'the (damn1) 'boy)))
 362         ; '("main content" i (like (the (("side effect" bad) . id) boy)))
 363
 364 ; However, the context (list 'the ... 'boy) is now being asked to operate
 365 ; on an element (("side effect" bad) . id), and it may complain it doesn't
 366 ; know what that is. It knows how to use 'id to get (list 'the 'id 'boy),
 367 ; and how to use 'bad to get (list 'the 'bad 'boy), but we're supposed to
 368 ; have something different here.
 369
 370 ; To get what we want we need to use (delimited) continuations:
 371         (reset (list "main content" 'i (list 'like (list 'the (damn2) 'boy))))
 372         ; '(("side effect" bad) ("main content" i (like (the id boy))))
 373
 374 ; or to get the side effect at the end:
 375
 376         (reset (list "main content" 'i (list 'like (list 'the (damn3) 'boy))))
 377         ; '(("main content" i (like (the id boy))) ("side effect" bad))
 378
 379 ; If you're working in the interactive interpreter, the outermost "reset" here
 380 ; is already in its default position, so it doesn't need to be explicitly
 381 ; specified:
 382
 383         (list "main content" 'i (list 'like (list 'the (damn2) 'boy)))
 384         ; '(("side effect" bad) ("main content" i (like (the id boy))))
 385
 386 ; However, if you're executing this as a file, you would need to include explicit resets.
 387
 388
 389
 390 ; Instead of using reset/shift you could use an element like "print" in
 391 ; building the side effect, as we did in class. Here you wouldn't require an
 392 ; explicit continuation, but as Chris said, that's because "print" already
 393 ; represents an implicit continuation.
 394
 395         (define damn4 (lambda () (begin (print "bad") 'id)))
 396         (list "main content" 'i (list 'like (list 'the (damn4) 'boy)))
 397         ; "bad"'("main content" i (like (the id boy)))
 398 ;
 399
 400