update
authorjim <jim@web>
Thu, 19 Mar 2015 02:32:18 +0000 (22:32 -0400)
committerLinux User <ikiwiki@localhost.members.linode.com>
Thu, 19 Mar 2015 02:32:18 +0000 (22:32 -0400)
topics/_week6_plexy.mdwn

index 79d081e..864d84e 100644 (file)
@@ -20,10 +20,10 @@ of *the solar system*, an object representing the relational concept
 denoted by *center*, and so on.  It doesn't matter precisely what that
 structure is, as long as it has distinct internal parts.
 
-Kaplan names this complex object "Plexy".  On Kaplan's assumptions,
+Kaplan names this complex object "Plexy".  Simplifying Kaplan's presentation, let's suppose
 the name *Plexy* is directly referential, and refers to the complex
 object that represents the meaning of *the center of mass of the solar
-system*.
+system*. Now consider:
 
     2. Plexy is a point.
 
@@ -64,18 +64,20 @@ the meaning of (2) can be `<{P}, point>`: radically different, as desired.
 In terms of the type systems we'll be developing over the next few
 weeks, the type of a DP will be a *sum type*: the disjoint union of the
 class of objects that a directly referential term can refer to, and
-the class of objects that can serve as the complex structure
-corresponding to a DP that is not directly referential.
+the class of objects that can serve as complex meaning structures
+corresponding to DPs as in (1) that are not directly referential.
 
 ## Motivating Maybe
 
-Kaplan goes on to use this solution to attack a different problem, the
+At the end of his footnote, Kaplan suggests using his proposal to help with a different problem, the
 problem of non-referring names.  Russell supposed that if a name had
 no referent (e.g., *Santa*), a sentence containing that name would
 have no meaning, since there would be no object to insert into the
 structure representing the meaning of that sentence.  But on Kaplan's
 scheme, there is no problem: *Santa is hungry* would denote `<{},
-hungry>`.  
+hungry>`. This can't be confused with a sentence saying that the empty set is
+hungry, since (supposing we directly refer to the empty set), that would
+denote `<{{}},hungry>`.
 
 This second idea has some obvious flaws.  For instance, it predicts
 that sentences that differ only in the choice of a non-referring name
@@ -87,12 +89,11 @@ Setting aside such objections, we will see over and over again the
 utility of the general strategy instantiated in Kaplan's strategy for representing the meaning of
 directly-referential expressions:
 
-    Kaplan's rule for directly-referential expressions:
-    a directly referential expression E contributes either
-    {}   if there is no object that E refers to, or else
-    {P}  if E refers to P
+> Kaplan's rule for directly-referential expressions: a directly referential expression E contributes either:  
+> {}   if there is no object that E refers to, or else  
+> {P}  if E refers to P
 
-In later weeks, we will call the general form of this technique the Maybe type, and the general strategy for deploying this type the Maybe monad.
+In later weeks, we will call the general form of this technique the "option" or "Maybe" type, and the general strategy for deploying this type "the Maybe monad." (In OCaml one has types like `int option`; in Haskell they are `Maybe Int`.)
 
 
 Kaplan, D. 1989. "Demonstratives. In J. Almog, J. Perry, & H. Wettstein