Index: doc/working/resolver_design.md
===================================================================
--- doc/working/resolver_design.md	(revision 59f9273d9a7dab609bcd3010343a3b307a0eb221)
+++ doc/working/resolver_design.md	(revision ac43954180f13a25ad6ec84de6b73da43f6f9223)
@@ -37,5 +37,5 @@
 
 An alternate possibility would be to only count two-arg constructors 
-`void ?{} ( To*, From )` as unsafe conversions; under this semantics, safe and  
+`void ?{} ( To*, From )` as unsafe conversions; under this semantics, safe and 
 explicit conversions should also have a compiler-enforced restriction to 
 ensure that they are two-arg functions (this restriction may be valuable 
@@ -69,5 +69,5 @@
 two chains of conversions, one among the signed integral types, another among 
 the unsigned, and to use monomorphic conversions to allow conversions between 
-signed and unsigned integer types).   
+signed and unsigned integer types).
 
 ### Implementation Details ###
@@ -509,5 +509,5 @@
 A variant of the above scheme would be to fix a maximum depth of polymorphic 
 type variables (16 seems like a reasonable choice) at which a parameter would 
-be considered to be effectively monomorphic, and to subtract the value  
+be considered to be effectively monomorphic, and to subtract the value 
 described above from that maximum, clamping the result to a minimum of 0. 
 Under this scheme, assuming a maximum value of 4, `int` has value 0, `T` has 
@@ -577,5 +577,5 @@
 specifying the (completely arbitrary) maximum depth as part of the language or 
 allowing the compiler to refuse to accept otherwise well-typed deeply-nested 
-polymorphic types.  
+polymorphic types.
 
 For purposes of determining polymorphism, the list of return types of a 
@@ -951,7 +951,7 @@
 `sizeof`, `alignof`, and `offsetof` expressions have at most a single 
 interpretation, of type `size_t`. 
-`sizeof` and `alignof` expressions take either a type or an expression as a  
-an argument; if the argument is a type, it must be a complete type which is 
-not a function type, if an expression, the expression must have a single 
+`sizeof` and `alignof` expressions take either a type or an expression as an 
+argument; if the argument is a type, it must be a complete type which is not a 
+function type, if an expression, the expression must have a single 
 interpretation, the type of which conforms to the same rules. 
 `offsetof` takes two arguments, a type and a member name; the type must be 
@@ -1620,2 +1620,9 @@
 			= delete;
 	}
+
+## Appendix E: Features to Add in Resolver Re-write ##
+* Reference types
+* Special types for 0 and 1 literals
+* Expression type for return statement that resolves similarly to ?=?
+  - This is to get rid of the kludge in the box pass that effectively 
+    re-implements the resolver poorly.