name change

[lambda.git] / code / gsv2.ml

diff --git a/code/gsv2.ml b/code/gsv2.ml
index 3230121..7f2775a 100644 (file)
--- a/code/gsv2.ml
+++ b/code/gsv2.ml
@@ -418,7 +418,7 @@ end
    of Na.
    SemNe (only for dynamic) would use "topics" or sequences of entities being discussed
    as payloads, so sent types are box(topic). What we really provide
    of Na.
    SemNe (only for dynamic) would use "topics" or sequences of entities being discussed
    as payloads, so sent types are box(topic). What we really provide

-   here is the Kleisli variation of this, so sent types = topic -> box(topic).
+   here is the Kleisli variation of this (SemNf), so sent types = topic -> box(topic).

 *)
  
 
 *)
  
 


@@ -861,7 +861,7 @@ end (* Sem8c *)
    Next we develop some semantics that are closer to their actual presentation. *)
 
 (* This develops Sem7c using in part the Kleisli strategy from Sem1b. *)
    Next we develop some semantics that are closer to their actual presentation. *)
 
 (* This develops Sem7c using in part the Kleisli strategy from Sem1b. *)

-module Sem7e = struct
+module Sem7f = struct

   let dynamic = true
   let extensional = true
 
   let dynamic = true
   let extensional = true
 


@@ -881,7 +881,7 @@ module Sem7e = struct
      Our meaning types (once we add worlds in 6e, below) will be:
        topic -> (store -> world -> ([topic] * store))
      We count a world as eliminated when it results in an empty list of topics.
      Our meaning types (once we add worlds in 6e, below) will be:
        topic -> (store -> world -> ([topic] * store))
      We count a world as eliminated when it results in an empty list of topics.

-     Note that our Sem8e doesn't yet properly handle Veltman's "might"; see remarks below.
+     Note that our Sem8f doesn't yet properly handle Veltman's "might"; see remarks below.

   *)
   type topic = entity list
   let topic0 = []
   *)
   type topic = entity list
   let topic0 = []


@@ -934,10 +934,10 @@ module Sem7e = struct
   let loves yy xx = wrap2 F.loves1 yy xx
   let thinks pp xx = fun top -> failwith "Unimplemented"
   let maybe pp = fun top -> failwith "Unimplemented"
   let loves yy xx = wrap2 F.loves1 yy xx
   let thinks pp xx = fun top -> failwith "Unimplemented"
   let maybe pp = fun top -> failwith "Unimplemented"

-end (* Sem7e *)
+end (* Sem7f *)

 
 

-(* Add intensionality to Sem7e. See comments there. *)
-module Sem8e = struct
+(* Add intensionality to Sem7f. See comments there. *)
+module Sem8f = struct

   let dynamic = true
   let extensional = false
 
   let dynamic = true
   let extensional = false
 


@@ -1021,7 +1021,7 @@ module Sem8e = struct
      [topic] as our payloads, so that sent types would then be: [topic] -> S'Y([topic]). All of the operations except
      for `maybe` would then have to emulate the operations of the List monad by hand (manually performing catmap etc).
      But `maybe` could examine the [topic] as a whole and decide whether to return box(it) or box([]).
      [topic] as our payloads, so that sent types would then be: [topic] -> S'Y([topic]). All of the operations except
      for `maybe` would then have to emulate the operations of the List monad by hand (manually performing catmap etc).
      But `maybe` could examine the [topic] as a whole and decide whether to return box(it) or box([]).

-     This would be to go back to the Sem4/Sem5 choices of monads (without list), and to implement the handling of lists
+     This would be to go back to the Sem5/Sem6 choices of monads (without list), and to implement the handling of lists

      by hand, as we did in the Sem1/Sem2 strategies.
 
      Additionally, we haven't tried here to handle non-rigid noun-types. That's why we can have sent types be:
      by hand, as we did in the Sem1/Sem2 strategies.
 
      Additionally, we haven't tried here to handle non-rigid noun-types. That's why we can have sent types be:


@@ -1045,7 +1045,7 @@ module Sem8e = struct
      Testifying to the "modularity" of monads, which we have been recommending as one of their prominent virtues.
   *)
 
      Testifying to the "modularity" of monads, which we have been recommending as one of their prominent virtues.
   *)
 

-end (* Sem8e *)
+end (* Sem8f *)

 
 module TestAll = struct
   print_endline "\nTesting Sem1a";;
 
 module TestAll = struct
   print_endline "\nTesting Sem1a";;


@@ -1053,21 +1053,21 @@ module TestAll = struct
   print_endline "\nTesting Sem1b";;
   module T1b = Test(Sem1b);;
   print_endline "\nTesting Sem3a";;
   print_endline "\nTesting Sem1b";;
   module T1b = Test(Sem1b);;
   print_endline "\nTesting Sem3a";;

-  module T2a = Test(Sem3a);;
+  module T3a = Test(Sem3a);;

   print_endline "\nTesting Sem3c";;
   print_endline "\nTesting Sem3c";;

-  module T2c = Test(Sem3c);;
+  module T3c = Test(Sem3c);;

   print_endline "\nTesting Sem4a";;
   print_endline "\nTesting Sem4a";;

-  module T3a = Test(Sem4a);;
+  module T4a = Test(Sem4a);;

   print_endline "\nTesting Sem4c";;
   print_endline "\nTesting Sem4c";;

-  module T3c = Test(Sem4c);;
+  module T4c = Test(Sem4c);;

   print_endline "\nTesting Sem7c";;
   print_endline "\nTesting Sem7c";;

-  module T5c = Test(Sem7c);;
-  print_endline "\nTesting Sem7e";;
-  module T5e = Test(Sem7e);;
+  module T7c = Test(Sem7c);;
+  print_endline "\nTesting Sem7f";;
+  module T7f = Test(Sem7f);;

   print_endline "\nTesting Sem8c";;
   print_endline "\nTesting Sem8c";;

-  module T6c = Test(Sem8c);;
-  print_endline "\nTesting Sem8e";;
-  module T6e = Test(Sem8e);;
+  module T8c = Test(Sem8c);;
+  print_endline "\nTesting Sem8f";;
+  module T8f = Test(Sem8f);;

   print_newline ()
 end
 
   print_newline ()
 end