index 9ddddc8..ce4d087 100644 (file)
@@ -1,3 +1,5 @@
+[[!toc]]
+
Substitution versus Environment-based Semantics
-----------------------------------------------

Substitution versus Environment-based Semantics
-----------------------------------------------

@@ -146,7 +148,7 @@ Here we'll use a different monad. It's called the **Reader monad**. We define it
(* we assume we've settled on some implementation of the environment *)
type env = (char * int) list;;

(* we assume we've settled on some implementation of the environment *)
type env = (char * int) list;;

type 'a reader = env -> 'a;;

type 'a reader = env -> 'a;;

@@ -155,7 +157,10 @@ Here we'll use a different monad. It's called the **Reader monad**. We define it

(* here's our bind operation; how does it work? *)

(* here's our bind operation; how does it work? *)
-               fun (e : env) -> f (u e) e
+               (* this can be written more compactly, but having it spelled out
+                  like this will be useful down the road *)
+               fun (e : env) -> let a = u e in let u' = f a in u' e
+

(* we also define two special-purpose operations on our reader-monad values *)

(* we also define two special-purpose operations on our reader-monad values *)

@@ -185,7 +190,7 @@ Now if we try:
# let result = eval (Let('x',Constant 1,Addition(Variable 'x',Constant 2)));;
- : int reader = <fun>

# let result = eval (Let('x',Constant 1,Addition(Variable 'x',Constant 2)));;
- : int reader = <fun>

-How do we see what integer that evaluates to? Well, it's an int-reader monad, which is a function from an `env` to an `int`, so we need to give it some `env` to operate on. We can give it the empty environment:
+How do we see what integer that evaluates to? Well, it's an int-Reader monad, which is a function from an `env` to an `int`, so we need to give it some `env` to operate on. We can give it the empty environment:

# result [];;
- : int = 3

# result [];;
- : int = 3
@@ -281,7 +286,7 @@ Substituting in the definition of `shift`, this is:
= fun v -> (fun e -> S (lookup i ((i, v e) :: e)) Alice)
= fun v -> (fun e -> S (v e) Alice)

= fun v -> (fun e -> S (lookup i ((i, v e) :: e)) Alice)
= fun v -> (fun e -> S (v e) Alice)

-In other words, it's a function from entity reader monads to a function from assignment functions to the result of applying S to the value of that entity reader-monad under that assignment function, and to Alice. Essentially the same as Heim and Kratzer's final value, except here we work with monadic values, such as functions from assignments to entities, rather than bare entities. And our derivation is completely compositional and uses the same composition rules for joining \[[who(i)]] to \[[Alice spurned i]] as it uses for joining \[[spurned]] to \[[i]] and \[[Alice]].
+In other words, it's a function from entity-Reader monads to a function from assignment functions to the result of applying S to the value of that entity reader-monad under that assignment function, and to Alice. Essentially the same as Heim and Kratzer's final value, except here we work with monadic values, such as functions from assignments to entities, rather than bare entities. And our derivation is completely compositional and uses the same composition rules for joining \[[who(i)]] to \[[Alice spurned i]] as it uses for joining \[[spurned]] to \[[i]] and \[[Alice]].

What's not to like?

What's not to like?