diff --git a/changelog b/changelog
index 43b1f80..e2cd290 100644
--- a/changelog
+++ b/changelog
@@ -1,3 +1,20 @@
+20080824 tpd src/interp/format.boot use ++X
+20080824 tpd src/algebra/tree.spad use ++X
+20080824 tpd src/algebra/string.spad use ++X
+20080824 tpd src/algebra/stream.spad use ++X
+20080824 tpd src/algebra/radix.spad use ++X
+20080824 tpd src/algebra/plot.spad use ++X
+20080824 tpd src/algebra/mkfunc.spad use ++X
+20080824 tpd src/algebra/mappkg.spad use ++X
+20080824 tpd src/algebra/listgcd.spad use ++X
+20080824 tpd src/algebra/fr.spad use ++X
+20080824 tpd src/algebra/curve.spad use ++X
+20080824 tpd src/algebra/carten.spad use ++X
+20080824 tpd src/algebra/card.spad use ++X
+20080824 tpd src/algebra/bags.spad use ++X
+20080824 tpd src/algebra/array2.spad use ++X
+20080824 tpd src/algebra/array1.spad use ++X
+20080824 tpd src/algebra/aggcat.spad use ++X
 20080823 tpd src/algebra/s.spad remove ++CapitalLetter syntax
 20080823 tpd src/algebra/multsqfr.spad remove ++CapitalLetter syntax
 20080823 tpd src/algebra/f07.spad remove ++CapitalLetter syntax
diff --git a/src/algebra/aggcat.spad.pamphlet b/src/algebra/aggcat.spad.pamphlet
index 69b8371..ee39ddd 100644
--- a/src/algebra/aggcat.spad.pamphlet
+++ b/src/algebra/aggcat.spad.pamphlet
@@ -1220,9 +1220,9 @@ TableAggregate(Key:SetCategory, Entry:SetCategory): Category ==
    table: () -> %
      ++ table()$T creates an empty table of type T.
      ++
-     ++E Data:=Record(age:Integer,gender:String)
-     ++E a1:AssociationList(String,Data):=table()
-     ++E a1."tim":=[55,"male"]$Data
+     ++X Data:=Record(age:Integer,gender:String)
+     ++X a1:AssociationList(String,Data):=table()
+     ++X a1."tim":=[55,"male"]$Data
 
    table: List Record(key:Key,entry:Entry) -> %
      ++ table([x,y,...,z]) creates a table consisting of entries
@@ -1623,8 +1623,8 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with
      ++ followed by the elements of v.
      ++ Note: \axiom{v = rest(w,#a)}.
      ++
-     ++E m:=[1,2,3]      
-     ++E concat(5,m)
+     ++X m:=[1,2,3]      
+     ++X concat(5,m)
 
    concat: (S,%) -> %
      ++ concat(x,u) returns aggregate consisting of x followed by
@@ -1632,15 +1632,15 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with
      ++ Note: if \axiom{v = concat(x,u)} then \axiom{x = first v}
      ++ and \axiom{u = rest v}.
      ++
-     ++E m:=[1,2,3]      
-     ++E concat(m,m)
+     ++X m:=[1,2,3]      
+     ++X concat(m,m)
 
    first: % -> S
      ++ first(u) returns the first element of u
      ++ (equivalently, the value at the current node).
      ++
-     ++E m:=[1,2,3]      
-     ++E first(m)
+     ++X m:=[1,2,3]      
+     ++X first(m)
 
    elt: (%,"first") -> S
      ++ elt(u,"first") (also written: \axiom{u . first}) is 
@@ -1650,16 +1650,16 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with
      ++ first(u,n) returns a copy of the first n 
      ++ (\axiom{n >= 0}) elements of u.
      ++
-     ++E m:=[1,2,3]      
-     ++E first(m,2)
+     ++X m:=[1,2,3]      
+     ++X first(m,2)
 
    rest: % -> %
      ++ rest(u) returns an aggregate consisting of all but the first
      ++ element of u
      ++ (equivalently, the next node of u).
      ++
-     ++E m:=[1,2,3]      
-     ++E rest m
+     ++X m:=[1,2,3]      
+     ++X rest m
 
    elt: (%,"rest") -> %
      ++ elt(%,"rest") (also written: \axiom{u.rest}) is
@@ -1669,15 +1669,15 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with
      ++ rest(u,n) returns the \axiom{n}th (n >= 0) node of u.
      ++ Note: \axiom{rest(u,0) = u}.
      ++
-     ++E m:=[1,2,3]      
-     ++E rest(m,2)
+     ++X m:=[1,2,3]      
+     ++X rest(m,2)
 
    last: % -> S
      ++ last(u) resturn the last element of u.
      ++ Note: for lists, \axiom{last(u) = u . (maxIndex u) = u . (# u - 1)}.
      ++
-     ++E m:=[1,2,3]      
-     ++E last m
+     ++X m:=[1,2,3]      
+     ++X last m
 
    elt: (%,"last") -> S
      ++ elt(u,"last") (also written: \axiom{u . last}) is equivalent to last u.
@@ -1686,70 +1686,70 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with
      ++ last(u,n) returns a copy of the last n (\axiom{n >= 0}) nodes of u.
      ++ Note: \axiom{last(u,n)} is a list of n elements.
      ++
-     ++E m:=[1,2,3]      
-     ++E last(m,2)
+     ++X m:=[1,2,3]      
+     ++X last(m,2)
 
    tail: % -> %
      ++ tail(u) returns the last node of u.
      ++ Note: if u is \axiom{shallowlyMutable},
      ++ \axiom{setrest(tail(u),v) = concat(u,v)}.
      ++
-     ++E m:=[1,2,3]      
-     ++E last(m,2)
+     ++X m:=[1,2,3]      
+     ++X last(m,2)
 
    second: % -> S
      ++ second(u) returns the second element of u.
      ++ Note: \axiom{second(u) = first(rest(u))}.
      ++
-     ++E m:=[1,2,3]      
-     ++E second m
+     ++X m:=[1,2,3]      
+     ++X second m
 
    third: % -> S
      ++ third(u) returns the third element of u.
      ++ Note: \axiom{third(u) = first(rest(rest(u)))}.
      ++
-     ++E m:=[1,2,3]      
-     ++E third m
+     ++X m:=[1,2,3]      
+     ++X third m
 
    cycleEntry: % -> %
      ++ cycleEntry(u) returns the head of a top-level cycle contained in
      ++ aggregate u, or \axiom{empty()} if none exists.
      ++
-     ++E m:=[1,2,3]      
-     ++E concat!(m,tail(m))
-     ++E cycleEntry m
+     ++X m:=[1,2,3]      
+     ++X concat!(m,tail(m))
+     ++X cycleEntry m
 
    cycleLength: % -> NonNegativeInteger
      ++ cycleLength(u) returns the length of a top-level cycle
      ++ contained  in aggregate u, or 0 is u has no such cycle.
      ++
-     ++E m:=[1,2,3]      
-     ++E concat!(m,tail(m))
-     ++E cycleLength m
+     ++X m:=[1,2,3]      
+     ++X concat!(m,tail(m))
+     ++X cycleLength m
 
    cycleTail: % -> %
      ++ cycleTail(u) returns the last node in the cycle, or
      ++ empty if none exists.
      ++
-     ++E m:=[1,2,3]      
-     ++E concat!(m,tail(m))
-     ++E cycleTail m
+     ++X m:=[1,2,3]      
+     ++X concat!(m,tail(m))
+     ++X cycleTail m
 
    if % has shallowlyMutable then
       concat_!: (%,%) -> %
 	++ concat!(u,v) destructively concatenates v to the end of u.
 	++ Note: \axiom{concat!(u,v) = setlast_!(u,v)}.
         ++
-        ++E m:=[1,2,3]
-        ++E n:=[4,5,6]
-        ++E concat!(m,n)
+        ++X m:=[1,2,3]
+        ++X n:=[4,5,6]
+        ++X concat!(m,n)
 
       concat_!: (%,S) -> %
 	++ concat!(u,x) destructively adds element x to the end of u.
 	++ Note: \axiom{concat!(a,x) = setlast!(a,[x])}.
         ++
-        ++E m:=[1,2,3]      
-        ++E concat!(m,5)
+        ++X m:=[1,2,3]      
+        ++X concat!(m,5)
 
       cycleSplit_!: % -> %
 	++ cycleSplit!(u) splits the aggregate by dropping off the cycle.
@@ -1758,20 +1758,20 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with
 	++ the head of the cycle, \axiom{cycleSplit!(w)} will drop v off w thus
 	++ destructively changing w to u, and returning v.
         ++
-        ++E m:=[1,2,3]
-        ++E concat!(m,m)
-        ++E n:=[4,5,6]
-        ++E p:=concat(n,m)
-        ++E q:=cycleSplit! p
-        ++E p
-        ++E q
+        ++X m:=[1,2,3]
+        ++X concat!(m,m)
+        ++X n:=[4,5,6]
+        ++X p:=concat(n,m)
+        ++X q:=cycleSplit! p
+        ++X p
+        ++X q
 
       setfirst_!: (%,S) -> S
 	++ setfirst!(u,x) destructively changes the first element of a to x.
         ++ 
-        ++E m:=[1,2,3]
-        ++E setfirst!(m,4)
-        ++E m
+        ++X m:=[1,2,3]
+        ++X setfirst!(m,4)
+        ++X m
 
       setelt: (%,"first",S) -> S
 	++ setelt(u,"first",x) (also written: \axiom{u.first := x}) is
@@ -1780,9 +1780,9 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with
       setrest_!: (%,%) -> %
 	++ setrest!(u,v) destructively changes the rest of u to v.
         ++
-        ++E m:=[1,2,3]
-        ++E setrest!(m,[4,5,6])
-        ++E m
+        ++X m:=[1,2,3]
+        ++X setrest!(m,[4,5,6])
+        ++X m
 
       setelt: (%,"rest",%) -> %
 	++ setelt(u,"rest",v) (also written: \axiom{u.rest := v}) 
@@ -1791,9 +1791,9 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with
       setlast_!: (%,S) -> S
 	++ setlast!(u,x) destructively changes the last element of u to x.
         ++
-        ++E m:=[1,2,3]
-        ++E setlast!(m,4)
-        ++E m
+        ++X m:=[1,2,3]
+        ++X setlast!(m,4)
+        ++X m
 
       setelt: (%,"last",S) -> S
 	++ setelt(u,"last",x) (also written: \axiom{u.last := b})
@@ -1804,10 +1804,10 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with
 	++ and \axiom{w = first(u,n)}, returning \axiom{v}.
 	++ Note: afterwards \axiom{rest(u,n)} returns \axiom{empty()}.
         ++
-        ++E m:=[1,2,3,4]
-        ++E n:=split!(m,2)
-        ++E m
-        ++E n
+        ++X m:=[1,2,3,4]
+        ++X n:=split!(m,2)
+        ++X m
+        ++X n
 
  add
   cycleMax ==> 1000
@@ -2717,10 +2717,10 @@ ExtensibleLinearAggregate(S:Type):Category == LinearAggregate S with
    delete_!: (%,Integer) -> %
      ++ delete!(u,i) destructively deletes the \axiom{i}th element of u.
      ++
-     ++E Data:=Record(age:Integer,gender:String)
-     ++E a1:AssociationList(String,Data):=table()
-     ++E a1."tim":=[55,"male"]$Data
-     ++E delete!(a1,1)
+     ++X Data:=Record(age:Integer,gender:String)
+     ++X a1:AssociationList(String,Data):=table()
+     ++X a1."tim":=[55,"male"]$Data
+     ++X delete!(a1,1)
 
    delete_!: (%,UniversalSegment(Integer)) -> %
      ++ delete!(u,i..j) destructively deletes elements u.i through u.j.
diff --git a/src/algebra/array1.spad.pamphlet b/src/algebra/array1.spad.pamphlet
index b4adc3d..7f4be27 100644
--- a/src/algebra/array1.spad.pamphlet
+++ b/src/algebra/array1.spad.pamphlet
@@ -232,9 +232,9 @@ PrimitiveArrayFunctions2(A, B): Exports == Implementation where
     ++ \spad{scan(f,a,r)} returns
     ++ \spad{[reduce(f,[a1],r),reduce(f,[a1,a2],r),...]}.
     ++
-    ++E T1:=PrimitiveArrayFunctions2(Integer,Integer)
-    ++E adder(a:Integer,b:Integer):Integer == a+b
-    ++E scan(adder,[i for i in 1..10],0)$T1
+    ++X T1:=PrimitiveArrayFunctions2(Integer,Integer)
+    ++X adder(a:Integer,b:Integer):Integer == a+b
+    ++X scan(adder,[i for i in 1..10],0)$T1
    
    reduce : ((A, B) -> B, VA, B) -> B
     ++ reduce(f,a,r) applies function f to each
@@ -244,17 +244,17 @@ PrimitiveArrayFunctions2(A, B): Exports == Implementation where
     ++ does \spad{3+(2+(1+0))}. Note: third argument r
     ++ may be regarded as the identity element for the function f.
     ++
-    ++E T1:=PrimitiveArrayFunctions2(Integer,Integer)
-    ++E adder(a:Integer,b:Integer):Integer == a+b
-    ++E reduce(adder,[i for i in 1..10],0)$T1
+    ++X T1:=PrimitiveArrayFunctions2(Integer,Integer)
+    ++X adder(a:Integer,b:Integer):Integer == a+b
+    ++X reduce(adder,[i for i in 1..10],0)$T1
 
    map : (A -> B, VA) -> VB
     ++ map(f,a) applies function f to each member of primitive array
     ++ \spad{a} resulting in a new primitive array over a
     ++ possibly different underlying domain.
     ++
-    ++E T1:=PrimitiveArrayFunctions2(Integer,Integer)
-    ++E map(x+->x+2,[i for i in 1..10])$T1
+    ++X T1:=PrimitiveArrayFunctions2(Integer,Integer)
+    ++X map(x+->x+2,[i for i in 1..10])$T1
 
   Implementation ==> add
     map(f, v)       == map(f, v)$O2
@@ -271,23 +271,23 @@ Tuple(S:Type): CoercibleTo(PrimitiveArray S) with
   coerce: PrimitiveArray S -> %
    ++ coerce(a) makes a tuple from primitive array a
    ++
-   ++E t1:PrimitiveArray(Integer):= [i for i in 1..10]
-   ++E t2:=coerce(t1)$Tuple(Integer)
+   ++X t1:PrimitiveArray(Integer):= [i for i in 1..10]
+   ++X t2:=coerce(t1)$Tuple(Integer)
 
   select: (%, NonNegativeInteger) -> S
    ++ select(x,n) returns the n-th element of tuple x.
    ++ tuples are 0-based
    ++
-   ++E t1:PrimitiveArray(Integer):= [i for i in 1..10]
-   ++E t2:=coerce(t1)$Tuple(Integer)
-   ++E select(t2,3)
+   ++X t1:PrimitiveArray(Integer):= [i for i in 1..10]
+   ++X t2:=coerce(t1)$Tuple(Integer)
+   ++X select(t2,3)
 
   length: % -> NonNegativeInteger
    ++ length(x) returns the number of elements in tuple x
    ++
-   ++E t1:PrimitiveArray(Integer):= [i for i in 1..10]
-   ++E t2:=coerce(t1)$Tuple(Integer)
-   ++E length(t2)
+   ++X t1:PrimitiveArray(Integer):= [i for i in 1..10]
+   ++X t2:=coerce(t1)$Tuple(Integer)
+   ++X length(t2)
 
   if S has SetCategory then SetCategory
  == add
@@ -337,31 +337,31 @@ IndexedFlexibleArray(S:Type, mn: Integer): Exports == Implementation where
     flexibleArray : List S -> %
      ++ flexibleArray(l) creates a flexible array from the list of elements l
      ++
-     ++E T1:=IndexedFlexibleArray(Integer,20)
-     ++E flexibleArray([i for i in 1..10])$T1
+     ++X T1:=IndexedFlexibleArray(Integer,20)
+     ++X flexibleArray([i for i in 1..10])$T1
 
     physicalLength : % -> NonNegativeInteger
      ++ physicalLength(x) returns the number of elements x can 
      ++ accomodate before growing
      ++
-     ++E T1:=IndexedFlexibleArray(Integer,20)
-     ++E t2:=flexibleArray([i for i in 1..10])$T1
-     ++E physicalLength t2
+     ++X T1:=IndexedFlexibleArray(Integer,20)
+     ++X t2:=flexibleArray([i for i in 1..10])$T1
+     ++X physicalLength t2
 
     physicalLength_!: (%, I) -> %
      ++ physicalLength!(x,n) changes the physical length of x to be n and
      ++ returns the new array.
      ++
-     ++E T1:=IndexedFlexibleArray(Integer,20)
-     ++E t2:=flexibleArray([i for i in 1..10])$T1
-     ++E physicalLength!(t2,15)
+     ++X T1:=IndexedFlexibleArray(Integer,20)
+     ++X t2:=flexibleArray([i for i in 1..10])$T1
+     ++X physicalLength!(t2,15)
 
     shrinkable: Boolean -> Boolean
      ++ shrinkable(b) sets the shrinkable attribute of flexible arrays to b
      ++ and returns the previous value
      ++
-     ++E T1:=IndexedFlexibleArray(Integer,20)
-     ++E shrinkable(false)$T1
+     ++X T1:=IndexedFlexibleArray(Integer,20)
+     ++X shrinkable(false)$T1
 
   Implementation == add
     Rep := Record(physLen:I, logLen:I, f:A)
@@ -1087,12 +1087,12 @@ OneDimensionalArray(S:Type): Exports == Implementation where
    oneDimensionalArray: List S -> %
     ++ oneDimensionalArray(l) creates an array from a list of elements l
     ++
-    ++E oneDimensionalArray [i**2 for i in 1..10]
+    ++X oneDimensionalArray [i**2 for i in 1..10]
   
    oneDimensionalArray: (NonNegativeInteger, S) -> %
     ++ oneDimensionalArray(n,s) creates an array from n copies of element s
     ++
-    ++E oneDimensionalArray(10,0.0)
+    ++X oneDimensionalArray(10,0.0)
 
   Implementation == IndexedOneDimensionalArray(S, ARRAYMININDEX) add
     oneDimensionalArray(u) ==
@@ -1125,9 +1125,9 @@ OneDimensionalArrayFunctions2(A, B): Exports == Implementation where
     ++ \spad{scan(f,a,r)} returns
     ++ \spad{[reduce(f,[a1],r),reduce(f,[a1,a2],r),...]}.
     ++
-    ++E T1:=OneDimensionalArrayFunctions2(Integer,Integer)
-    ++E adder(a:Integer,b:Integer):Integer == a+b
-    ++E scan(adder,[i for i in 1..10],0)$T1
+    ++X T1:=OneDimensionalArrayFunctions2(Integer,Integer)
+    ++X adder(a:Integer,b:Integer):Integer == a+b
+    ++X scan(adder,[i for i in 1..10],0)$T1
 
    reduce : ((A, B) -> B, VA, B) -> B
     ++ reduce(f,a,r) applies function f to each
@@ -1137,17 +1137,17 @@ OneDimensionalArrayFunctions2(A, B): Exports == Implementation where
     ++ does \spad{3+(2+(1+0))}. Note: third argument r
     ++ may be regarded as the identity element for the function f.
     ++
-    ++E T1:=OneDimensionalArrayFunctions2(Integer,Integer)
-    ++E adder(a:Integer,b:Integer):Integer == a+b
-    ++E reduce(adder,[i for i in 1..10],0)$T1
+    ++X T1:=OneDimensionalArrayFunctions2(Integer,Integer)
+    ++X adder(a:Integer,b:Integer):Integer == a+b
+    ++X reduce(adder,[i for i in 1..10],0)$T1
 
    map : (A -> B, VA) -> VB
     ++ map(f,a) applies function f to each member of one-dimensional array
     ++ \spad{a} resulting in a new one-dimensional array over a
     ++ possibly different underlying domain.
     ++
-    ++E T1:=OneDimensionalArrayFunctions2(Integer,Integer)
-    ++E map(x+->x+2,[i for i in 1..10])$T1
+    ++X T1:=OneDimensionalArrayFunctions2(Integer,Integer)
+    ++X map(x+->x+2,[i for i in 1..10])$T1
 
   Implementation ==> add
     map(f, v)       == map(f, v)$O2
diff --git a/src/algebra/array2.spad.pamphlet b/src/algebra/array2.spad.pamphlet
index e6a8b7a..a6f9cd7 100644
--- a/src/algebra/array2.spad.pamphlet
+++ b/src/algebra/array2.spad.pamphlet
@@ -46,51 +46,51 @@ TwoDimensionalArrayCategory(R,Row,Col): Category == Definition where
    new: (NonNegativeInteger,NonNegativeInteger,R) -> %
     ++ new(m,n,r) is an m-by-n array all of whose entries are r
     ++
-    ++E arr : ARRAY2 INT := new(5,4,0)
+    ++X arr : ARRAY2 INT := new(5,4,0)
     
    fill_!: (%,R) -> %
     ++ fill!(m,r) fills m with r's
     ++
-    ++E arr : ARRAY2 INT := new(5,4,0)
-    ++E fill!(arr,10)
+    ++X arr : ARRAY2 INT := new(5,4,0)
+    ++X fill!(arr,10)
 
 --% Size inquiries
 
    minRowIndex : % -> Integer
     ++ minRowIndex(m) returns the index of the 'first' row of the array m
     ++
-    ++E arr : ARRAY2 INT := new(5,4,10)
-    ++E minRowIndex(arr)
+    ++X arr : ARRAY2 INT := new(5,4,10)
+    ++X minRowIndex(arr)
 
    maxRowIndex : % -> Integer
     ++ maxRowIndex(m) returns the index of the 'last' row of the array m
     ++
-    ++E arr : ARRAY2 INT := new(5,4,10)
-    ++E maxRowIndex(arr)
+    ++X arr : ARRAY2 INT := new(5,4,10)
+    ++X maxRowIndex(arr)
 
    minColIndex : % -> Integer
     ++ minColIndex(m) returns the index of the 'first' column of the array m
     ++
-    ++E arr : ARRAY2 INT := new(5,4,10)
-    ++E minColIndex(arr)
+    ++X arr : ARRAY2 INT := new(5,4,10)
+    ++X minColIndex(arr)
 
    maxColIndex : % -> Integer
     ++ maxColIndex(m) returns the index of the 'last' column of the array m
     ++
-    ++E arr : ARRAY2 INT := new(5,4,10)
-    ++E maxColIndex(arr)
+    ++X arr : ARRAY2 INT := new(5,4,10)
+    ++X maxColIndex(arr)
 
    nrows : % -> NonNegativeInteger
     ++ nrows(m) returns the number of rows in the array m
     ++
-    ++E arr : ARRAY2 INT := new(5,4,10)
-    ++E nrows(arr)
+    ++X arr : ARRAY2 INT := new(5,4,10)
+    ++X nrows(arr)
 
    ncols : % -> NonNegativeInteger
     ++ ncols(m) returns the number of columns in the array m
     ++
-    ++E arr : ARRAY2 INT := new(5,4,10)
-    ++E ncols(arr)
+    ++X arr : ARRAY2 INT := new(5,4,10)
+    ++X ncols(arr)
 
 --% Part extractions
 
@@ -99,45 +99,45 @@ TwoDimensionalArrayCategory(R,Row,Col): Category == Definition where
     ++ column of the array m
     ++ error check to determine if indices are in proper ranges
     ++
-    ++E arr : ARRAY2 INT := new(5,4,10)
-    ++E elt(arr,1,1)
+    ++X arr : ARRAY2 INT := new(5,4,10)
+    ++X elt(arr,1,1)
 
    qelt: (%,Integer,Integer) -> R
     ++ qelt(m,i,j) returns the element in the ith row and jth
     ++ column of the array m
     ++ NO error check to determine if indices are in proper ranges
     ++
-    ++E arr : ARRAY2 INT := new(5,4,10)
-    ++E qelt(arr,1,1)
+    ++X arr : ARRAY2 INT := new(5,4,10)
+    ++X qelt(arr,1,1)
 
    elt: (%,Integer,Integer,R) -> R
     ++ elt(m,i,j,r) returns the element in the ith row and jth
     ++ column of the array m, if m has an ith row and a jth column,
     ++ and returns r otherwise
     ++
-    ++E arr : ARRAY2 INT := new(5,4,10)
-    ++E elt(arr,1,1,6)
-    ++E elt(arr,1,10,6)
+    ++X arr : ARRAY2 INT := new(5,4,10)
+    ++X elt(arr,1,1,6)
+    ++X elt(arr,1,10,6)
 
    row: (%,Integer) -> Row
     ++ row(m,i) returns the ith row of m
     ++ error check to determine if index is in proper ranges
     ++
-    ++E arr : ARRAY2 INT := new(5,4,10)
-    ++E row(arr,1)
+    ++X arr : ARRAY2 INT := new(5,4,10)
+    ++X row(arr,1)
 
    column: (%,Integer) -> Col
     ++ column(m,j) returns the jth column of m
     ++ error check to determine if index is in proper ranges
     ++
-    ++E arr : ARRAY2 INT := new(5,4,10)
-    ++E column(arr,1)
+    ++X arr : ARRAY2 INT := new(5,4,10)
+    ++X column(arr,1)
 
    parts: % -> List R
     ++ parts(m) returns a list of the elements of m in row major order
     ++
-    ++E arr : ARRAY2 INT := new(5,4,10)
-    ++E parts(arr)
+    ++X arr : ARRAY2 INT := new(5,4,10)
+    ++X parts(arr)
 
 --% Part assignments
 
@@ -147,34 +147,34 @@ TwoDimensionalArrayCategory(R,Row,Col): Category == Definition where
     ++ column of m to r
     ++ error check to determine if indices are in proper ranges
     ++
-    ++E arr : ARRAY2 INT := new(5,4,0)
-    ++E setelt(arr,1,1,17)
+    ++X arr : ARRAY2 INT := new(5,4,0)
+    ++X setelt(arr,1,1,17)
 
    qsetelt_!: (%,Integer,Integer,R) -> R
     ++ qsetelt!(m,i,j,r) sets the element in the ith row and jth
     ++ column of m to r
     ++ NO error check to determine if indices are in proper ranges
     ++
-    ++E arr : ARRAY2 INT := new(5,4,0)
-    ++E qsetelt!(arr,1,1,17)
+    ++X arr : ARRAY2 INT := new(5,4,0)
+    ++X qsetelt!(arr,1,1,17)
 
    setRow_!: (%,Integer,Row) -> %
     ++ setRow!(m,i,v) sets to ith row of m to v
     ++
-    ++E T1:=TwoDimensionalArray Integer
-    ++E arr:T1:= new(5,4,0)
-    ++E T2:=OneDimensionalArray Integer
-    ++E arow:=construct([1,2,3,4]::List(INT))$T2
-    ++E setRow!(arr,1,arow)$T1
+    ++X T1:=TwoDimensionalArray Integer
+    ++X arr:T1:= new(5,4,0)
+    ++X T2:=OneDimensionalArray Integer
+    ++X arow:=construct([1,2,3,4]::List(INT))$T2
+    ++X setRow!(arr,1,arow)$T1
 
    setColumn_!: (%,Integer,Col) -> %
     ++ setColumn!(m,j,v) sets to jth column of m to v
     ++
-    ++E T1:=TwoDimensionalArray Integer
-    ++E arr:T1:= new(5,4,0)
-    ++E T2:=OneDimensionalArray Integer
-    ++E acol:=construct([1,2,3,4,5]::List(INT))$T2
-    ++E setColumn!(arr,1,acol)$T1
+    ++X T1:=TwoDimensionalArray Integer
+    ++X arr:T1:= new(5,4,0)
+    ++X T2:=OneDimensionalArray Integer
+    ++X acol:=construct([1,2,3,4,5]::List(INT))$T2
+    ++X setColumn!(arr,1,acol)$T1
 
 --% Map and Zip
 
@@ -182,23 +182,23 @@ TwoDimensionalArrayCategory(R,Row,Col): Category == Definition where
     ++ map(f,a) returns \spad{b}, where \spad{b(i,j) = f(a(i,j))} 
     ++ for all \spad{i, j}
     ++
-    ++E arr : ARRAY2 INT := new(5,4,10)
-    ++E map(-,arr)
-    ++E map((x +-> x + x),arr)
+    ++X arr : ARRAY2 INT := new(5,4,10)
+    ++X map(-,arr)
+    ++X map((x +-> x + x),arr)
 
    map_!: (R -> R,%) -> %
     ++ map!(f,a)  assign \spad{a(i,j)} to \spad{f(a(i,j))} for all \spad{i, j}
     ++
-    ++E arr : ARRAY2 INT := new(5,4,10)
-    ++E map!(-,arr)
+    ++X arr : ARRAY2 INT := new(5,4,10)
+    ++X map!(-,arr)
 
    map:((R,R) -> R,%,%) -> %
     ++ map(f,a,b) returns \spad{c}, where \spad{c(i,j) = f(a(i,j),b(i,j))}
     ++ for all \spad{i, j}
     ++
-    ++E adder(a:Integer,b:Integer):Integer == a+b
-    ++E arr : ARRAY2 INT := new(5,4,10)
-    ++E map(adder,arr,arr)
+    ++X adder(a:Integer,b:Integer):Integer == a+b
+    ++X arr : ARRAY2 INT := new(5,4,10)
+    ++X map(adder,arr,arr)
 
    map:((R,R) -> R,%,%,R) -> %
     ++ map(f,a,b,r) returns \spad{c}, where \spad{c(i,j) = f(a(i,j),b(i,j))}
@@ -207,10 +207,10 @@ TwoDimensionalArrayCategory(R,Row,Col): Category == Definition where
     ++ else \spad{c(i,j) = f(a(i,j),r)} when \spad{b(i,j)} does not exist;
     ++ otherwise \spad{c(i,j) = f(r,r)}.
     ++
-    ++E adder(a:Integer,b:Integer):Integer == a+b
-    ++E arr1 : ARRAY2 INT := new(5,4,10)
-    ++E arr2 : ARRAY2 INT := new(3,3,10)
-    ++E map(adder,arr1,arr2,17)
+    ++X adder(a:Integer,b:Integer):Integer == a+b
+    ++X arr1 : ARRAY2 INT := new(5,4,10)
+    ++X arr2 : ARRAY2 INT := new(3,3,10)
+    ++X map(adder,arr1,arr2,17)
 
   add
 
diff --git a/src/algebra/bags.spad.pamphlet b/src/algebra/bags.spad.pamphlet
index 65efc9e..a2fe3f3 100644
--- a/src/algebra/bags.spad.pamphlet
+++ b/src/algebra/bags.spad.pamphlet
@@ -32,7 +32,7 @@ Stack(S:SetCategory): StackAggregate S with
       ++ stack([x,y,...,z]) creates a stack with first (top)
       ++ element x, second element y,...,and last element z.
       ++
-      ++E a:Stack INT:= stack [1,2,3,4,5]
+      ++X a:Stack INT:= stack [1,2,3,4,5]
 
   == add
     Rep := Reference List S
@@ -81,7 +81,7 @@ ArrayStack(S:SetCategory): StackAggregate(S) with
       ++ arrayStack([x,y,...,z]) creates an array stack with first (top)
       ++ element x, second element y,...,and last element z.
       ++
-      ++E c:ArrayStack INT:= arrayStack [1,2,3,4,5]
+      ++X c:ArrayStack INT:= arrayStack [1,2,3,4,5]
 
   == add
     Rep := IndexedFlexibleArray(S,0)
@@ -134,7 +134,7 @@ Queue(S:SetCategory): QueueAggregate S with
       ++ queue([x,y,...,z]) creates a queue with first (top)
       ++ element x, second element y,...,and last (bottom) element z.
       ++
-      ++E e:Queue INT:= queue [1,2,3,4,5]
+      ++X e:Queue INT:= queue [1,2,3,4,5]
 
   == Stack S add
     Rep := Reference List S
@@ -181,7 +181,7 @@ Dequeue(S:SetCategory): DequeueAggregate S with
        ++ dequeue([x,y,...,z]) creates a dequeue with first (top or front)
        ++ element x, second element y,...,and last (bottom or back) element z.
        ++
-       ++E g:Dequeue INT:= dequeue [1,2,3,4,5]
+       ++X g:Dequeue INT:= dequeue [1,2,3,4,5]
 
   == Queue S add
     Rep := Reference List S
@@ -376,7 +376,7 @@ Heap(S:OrderedSet): Exports == Implementation where
       ++ heap(ls) creates a heap of elements consisting of the 
       ++ elements of ls.
       ++
-      ++E i:Heap INT := heap [1,6,3,7,5,2,4]
+      ++X i:Heap INT := heap [1,6,3,7,5,2,4]
 
   Implementation == IndexedFlexibleArray(S,0) add
     Rep := IndexedFlexibleArray( S,0)
diff --git a/src/algebra/card.spad.pamphlet b/src/algebra/card.spad.pamphlet
index 14c1ae9..7eb9afa 100644
--- a/src/algebra/card.spad.pamphlet
+++ b/src/algebra/card.spad.pamphlet
@@ -381,62 +381,62 @@ CardinalNumber: Join(OrderedSet, AbelianMonoid, Monoid,
             ++ \spad{x - y} returns an element z such that 
             ++ \spad{z+y=x} or "failed" if no such element exists.
             ++
-            ++E c2:=2::CardinalNumber
-            ++E c2-c2
-            ++E A1:=Aleph 1
-            ++E A1-c2
+            ++X c2:=2::CardinalNumber
+            ++X c2-c2
+            ++X A1:=Aleph 1
+            ++X A1-c2
 
         "**": (%, %) -> %
             ++ \spad{x**y} returns \spad{#(X**Y)} where \spad{X**Y} is defined
             ++  as \spad{\{g| g:Y->X\}}.
             ++
-            ++E c2:=2::CardinalNumber
-            ++E c2**c2
-            ++E A1:=Aleph 1
-            ++E A1**c2
-            ++E generalizedContinuumHypothesisAssumed true
-            ++E A1**A1
+            ++X c2:=2::CardinalNumber
+            ++X c2**c2
+            ++X A1:=Aleph 1
+            ++X A1**c2
+            ++X generalizedContinuumHypothesisAssumed true
+            ++X A1**A1
 
         Aleph: NonNegativeInteger -> %
             ++ Aleph(n) provides the named (infinite) cardinal number.
             ++
-            ++E A0:=Aleph 0
+            ++X A0:=Aleph 0
 
         finite?: % -> Boolean
             ++ finite?(\spad{a}) determines whether 
             ++ \spad{a} is a finite cardinal, i.e. an integer.
             ++
-            ++E c2:=2::CardinalNumber
-            ++E finite? c2
-            ++E A0:=Aleph 0
-            ++E finite? A0
+            ++X c2:=2::CardinalNumber
+            ++X finite? c2
+            ++X A0:=Aleph 0
+            ++X finite? A0
 
         countable?: % -> Boolean
             ++ countable?(\spad{a}) determines 
             ++ whether \spad{a} is a countable cardinal,
             ++ i.e. an integer or \spad{Aleph 0}.
             ++
-            ++E c2:=2::CardinalNumber
-            ++E countable? c2
-            ++E A0:=Aleph 0
-            ++E countable? A0
-            ++E A1:=Aleph 1
-            ++E countable? A1
+            ++X c2:=2::CardinalNumber
+            ++X countable? c2
+            ++X A0:=Aleph 0
+            ++X countable? A0
+            ++X A1:=Aleph 1
+            ++X countable? A1
 
         generalizedContinuumHypothesisAssumed?: () -> Boolean
             ++ generalizedContinuumHypothesisAssumed?()
             ++ tests if the hypothesis is currently assumed.
             ++
-            ++E generalizedContinuumHypothesisAssumed?
+            ++X generalizedContinuumHypothesisAssumed?
 
         generalizedContinuumHypothesisAssumed:  Boolean -> Boolean
             ++ generalizedContinuumHypothesisAssumed(bool)
             ++ is used to dictate whether the hypothesis is to be assumed.
             ++
-            ++E generalizedContinuumHypothesisAssumed true
-            ++E a:=Aleph 0
-            ++E c:=2**a
-            ++E f:=2**c
+            ++X generalizedContinuumHypothesisAssumed true
+            ++X a:=Aleph 0
+            ++X c:=2**a
+            ++X f:=2**c
     == add
         NNI ==> NonNegativeInteger
         FINord   ==> -1
diff --git a/src/algebra/carten.spad.pamphlet b/src/algebra/carten.spad.pamphlet
index 8d39805..d1880f4 100644
--- a/src/algebra/carten.spad.pamphlet
+++ b/src/algebra/carten.spad.pamphlet
@@ -1083,94 +1083,94 @@ CartesianTensor(minix, dim, R): Exports == Implementation where
         coerce: DP(dim, R) -> %
             ++ coerce(v) views a vector as a rank 1 tensor.
             ++
-            ++E v:DirectProduct(2,Integer):=directProduct [3,4]
-            ++E tv:CartesianTensor(1,2,Integer):=v
+            ++X v:DirectProduct(2,Integer):=directProduct [3,4]
+            ++X tv:CartesianTensor(1,2,Integer):=v
 
         coerce: SM(dim, R)  -> %
             ++ coerce(m) views a matrix as a rank 2 tensor.
             ++
-            ++E v:SquareMatrix(2,Integer):=[[1,2],[3,4]]
-            ++E tv:CartesianTensor(1,2,Integer):=v
+            ++X v:SquareMatrix(2,Integer):=[[1,2],[3,4]]
+            ++X tv:CartesianTensor(1,2,Integer):=v
 
         coerce: List R -> %
             ++ coerce([r_1,...,r_dim]) allows tensors to be constructed
             ++ using lists.
             ++
-            ++E v:=[2,3]
-            ++E tv:CartesianTensor(1,2,Integer):=v
+            ++X v:=[2,3]
+            ++X tv:CartesianTensor(1,2,Integer):=v
 
         coerce: List % -> %
             ++ coerce([t_1,...,t_dim]) allows tensors to be constructed
             ++ using lists.
             ++
-            ++E v:=[2,3]
-            ++E tv:CartesianTensor(1,2,Integer):=v
-            ++E tm:CartesianTensor(1,2,Integer):=[tv,tv]
+            ++X v:=[2,3]
+            ++X tv:CartesianTensor(1,2,Integer):=v
+            ++X tm:CartesianTensor(1,2,Integer):=[tv,tv]
 
         rank: % -> NNI
             ++ rank(t) returns the tensorial rank of t (that is, the
             ++ number of indices).  This is the same as the graded module
             ++ degree.
             ++
-            ++E CT:=CARTEN(1,2,Integer)
-            ++E t0:CT:=8
-            ++E rank t0
+            ++X CT:=CARTEN(1,2,Integer)
+            ++X t0:CT:=8
+            ++X rank t0
 
         elt: (%) -> R
             ++ elt(t) gives the component of a rank 0 tensor.
             ++
-            ++E tv:CartesianTensor(1,2,Integer):=8
-            ++E elt(tv)
-            ++E tv[]
+            ++X tv:CartesianTensor(1,2,Integer):=8
+            ++X elt(tv)
+            ++X tv[]
 
         elt: (%, I) -> R
             ++ elt(t,i) gives a component of a rank 1 tensor.
             ++
-            ++E v:=[2,3]
-            ++E tv:CartesianTensor(1,2,Integer):=v
-            ++E elt(tv,2)
-            ++E tv[2]
+            ++X v:=[2,3]
+            ++X tv:CartesianTensor(1,2,Integer):=v
+            ++X elt(tv,2)
+            ++X tv[2]
 
         elt: (%, I, I) -> R
             ++ elt(t,i,j) gives a component of a rank 2 tensor.
             ++
-            ++E v:=[2,3]
-            ++E tv:CartesianTensor(1,2,Integer):=v
-            ++E tm:CartesianTensor(1,2,Integer):=[tv,tv]
-            ++E elt(tm,2,2)
-            ++E tm[2,2]
+            ++X v:=[2,3]
+            ++X tv:CartesianTensor(1,2,Integer):=v
+            ++X tm:CartesianTensor(1,2,Integer):=[tv,tv]
+            ++X elt(tm,2,2)
+            ++X tm[2,2]
 
         elt: (%, I, I, I) -> R
             ++ elt(t,i,j,k) gives a component of a rank 3 tensor.
             ++
-            ++E v:=[2,3]
-            ++E tv:CartesianTensor(1,2,Integer):=v
-            ++E tm:CartesianTensor(1,2,Integer):=[tv,tv]
-            ++E tn:CartesianTensor(1,2,Integer):=[tm,tm]
-            ++E elt(tn,2,2,2)
-            ++E tn[2,2,2]
+            ++X v:=[2,3]
+            ++X tv:CartesianTensor(1,2,Integer):=v
+            ++X tm:CartesianTensor(1,2,Integer):=[tv,tv]
+            ++X tn:CartesianTensor(1,2,Integer):=[tm,tm]
+            ++X elt(tn,2,2,2)
+            ++X tn[2,2,2]
 
         elt: (%, I, I, I, I) -> R
             ++ elt(t,i,j,k,l) gives a component of a rank 4 tensor.
             ++
-            ++E v:=[2,3]
-            ++E tv:CartesianTensor(1,2,Integer):=v
-            ++E tm:CartesianTensor(1,2,Integer):=[tv,tv]
-            ++E tn:CartesianTensor(1,2,Integer):=[tm,tm]
-            ++E tp:CartesianTensor(1,2,Integer):=[tn,tn]
-            ++E elt(tp,2,2,2,2)
-            ++E tp[2,2,2,2]
+            ++X v:=[2,3]
+            ++X tv:CartesianTensor(1,2,Integer):=v
+            ++X tm:CartesianTensor(1,2,Integer):=[tv,tv]
+            ++X tn:CartesianTensor(1,2,Integer):=[tm,tm]
+            ++X tp:CartesianTensor(1,2,Integer):=[tn,tn]
+            ++X elt(tp,2,2,2,2)
+            ++X tp[2,2,2,2]
 
         elt: (%, List I) -> R
             ++ elt(t,[i1,...,iN]) gives a component of a rank \spad{N} tensor.
             ++
-            ++E v:=[2,3]
-            ++E tv:CartesianTensor(1,2,Integer):=v
-            ++E tm:CartesianTensor(1,2,Integer):=[tv,tv]
-            ++E tn:CartesianTensor(1,2,Integer):=[tm,tm]
-            ++E tp:CartesianTensor(1,2,Integer):=[tn,tn]
-            ++E tq:CartesianTensor(1,2,Integer):=[tp,tp]
-            ++E elt(tq,[2,2,2,2,2])
+            ++X v:=[2,3]
+            ++X tv:CartesianTensor(1,2,Integer):=v
+            ++X tm:CartesianTensor(1,2,Integer):=[tv,tv]
+            ++X tn:CartesianTensor(1,2,Integer):=[tm,tm]
+            ++X tp:CartesianTensor(1,2,Integer):=[tn,tn]
+            ++X tq:CartesianTensor(1,2,Integer):=[tp,tp]
+            ++X elt(tq,[2,2,2,2,2])
 
         -- This specializes the documentation from GradedAlgebra.
         product: (%,%) -> %
@@ -1179,11 +1179,11 @@ CartesianTensor(minix, dim, R): Exports == Implementation where
             ++ s and t, then \spad{r} is a rank 4 tensor given by
             ++     \spad{r(i,j,k,l) = s(i,j)*t(k,l)}.
             ++
-            ++E m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]]
-            ++E Tm:CartesianTensor(1,2,Integer):=m
-            ++E n:SquareMatrix(2,Integer):=matrix [[2,3],[0,1]]
-            ++E Tn:CartesianTensor(1,2,Integer):=n
-            ++E Tmn:=product(Tm,Tn)
+            ++X m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]]
+            ++X Tm:CartesianTensor(1,2,Integer):=m
+            ++X n:SquareMatrix(2,Integer):=matrix [[2,3],[0,1]]
+            ++X Tn:CartesianTensor(1,2,Integer):=n
+            ++X Tmn:=product(Tm,Tn)
 
         "*": (%, %) -> %
             ++ s*t is the inner product of the tensors s and t which contracts
@@ -1193,11 +1193,11 @@ CartesianTensor(minix, dim, R): Exports == Implementation where
             ++ This is compatible with the use of \spad{M*v} to denote
             ++ the matrix-vector inner product.
             ++
-            ++E m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]]
-            ++E Tm:CartesianTensor(1,2,Integer):=m
-            ++E v:DirectProduct(2,Integer):=directProduct [3,4]
-            ++E Tv:CartesianTensor(1,2,Integer):=v
-            ++E Tm*Tv
+            ++X m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]]
+            ++X Tm:CartesianTensor(1,2,Integer):=m
+            ++X v:DirectProduct(2,Integer):=directProduct [3,4]
+            ++X Tv:CartesianTensor(1,2,Integer):=v
+            ++X Tm*Tv
 
         contract:  (%, Integer, %, Integer) -> %
             ++ contract(t,i,s,j) is the inner product of tenors s and t
@@ -1208,11 +1208,11 @@ CartesianTensor(minix, dim, R): Exports == Implementation where
             ++ the rank 4 \spad{(= 3 + 3 - 2)} tensor  given by
             ++     \spad{r(i,j,k,l) = sum(h=1..dim,s(i,h,j)*t(h,k,l))}.
             ++
-            ++E m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]]
-            ++E Tm:CartesianTensor(1,2,Integer):=m
-            ++E v:DirectProduct(2,Integer):=directProduct [3,4]
-            ++E Tv:CartesianTensor(1,2,Integer):=v
-            ++E Tmv:=contract(Tm,2,Tv,1)
+            ++X m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]]
+            ++X Tm:CartesianTensor(1,2,Integer):=m
+            ++X v:DirectProduct(2,Integer):=directProduct [3,4]
+            ++X Tv:CartesianTensor(1,2,Integer):=v
+            ++X Tmv:=contract(Tm,2,Tv,1)
 
         contract:  (%, Integer, Integer)    -> %
             ++ contract(t,i,j) is the contraction of tensor t which
@@ -1222,11 +1222,11 @@ CartesianTensor(minix, dim, R): Exports == Implementation where
             ++ \spad{r} is the rank 2 \spad{(= 4 - 2)} tensor given by
             ++     \spad{r(i,j) = sum(h=1..dim,t(h,i,h,j))}.
             ++
-            ++E m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]]
-            ++E Tm:CartesianTensor(1,2,Integer):=m
-            ++E v:DirectProduct(2,Integer):=directProduct [3,4]
-            ++E Tv:CartesianTensor(1,2,Integer):=v
-            ++E Tmv:=contract(Tm,2,1)
+            ++X m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]]
+            ++X Tm:CartesianTensor(1,2,Integer):=m
+            ++X v:DirectProduct(2,Integer):=directProduct [3,4]
+            ++X Tv:CartesianTensor(1,2,Integer):=v
+            ++X Tmv:=contract(Tm,2,1)
 
         transpose: % -> %
             ++ transpose(t) exchanges the first and last indices of t.
@@ -1234,9 +1234,9 @@ CartesianTensor(minix, dim, R): Exports == Implementation where
             ++ tensor t, then \spad{r} is the rank 4 tensor given by
             ++     \spad{r(i,j,k,l) = t(l,j,k,i)}.
             ++
-            ++E m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]]
-            ++E Tm:CartesianTensor(1,2,Integer):=m
-            ++E transpose(Tm)
+            ++X m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]]
+            ++X Tm:CartesianTensor(1,2,Integer):=m
+            ++X transpose(Tm)
 
         transpose: (%, Integer, Integer) -> %
             ++ transpose(t,i,j) exchanges the \spad{i}-th and \spad{j}-th 
@@ -1245,10 +1245,10 @@ CartesianTensor(minix, dim, R): Exports == Implementation where
             ++ given by
             ++     \spad{r(i,j,k,l) = t(i,k,j,l)}.
             ++
-            ++E m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]]
-            ++E tm:CartesianTensor(1,2,Integer):=m
-            ++E tn:CartesianTensor(1,2,Integer):=[tm,tm]
-            ++E transpose(tn,1,2)
+            ++X m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]]
+            ++X tm:CartesianTensor(1,2,Integer):=m
+            ++X tn:CartesianTensor(1,2,Integer):=[tm,tm]
+            ++X transpose(tn,1,2)
 
         reindex: (%, List Integer) -> %
             ++ reindex(t,[i1,...,idim]) permutes the indices of t.
@@ -1257,10 +1257,10 @@ CartesianTensor(minix, dim, R): Exports == Implementation where
             ++ then \spad{r} is the rank for tensor given by
             ++     \spad{r(i,j,k,l) = t(l,i,j,k)}.
             ++ 
-            ++E n:SquareMatrix(2,Integer):=matrix [[2,3],[0,1]]
-            ++E tn:CartesianTensor(1,2,Integer):=n
-            ++E p:=product(tn,tn)
-            ++E reindex(p,[4,3,2,1])
+            ++X n:SquareMatrix(2,Integer):=matrix [[2,3],[0,1]]
+            ++X tn:CartesianTensor(1,2,Integer):=n
+            ++X p:=product(tn,tn)
+            ++X reindex(p,[4,3,2,1])
  
         kroneckerDelta:  () -> %
             ++ kroneckerDelta() is the rank 2 tensor defined by
@@ -1268,7 +1268,7 @@ CartesianTensor(minix, dim, R): Exports == Implementation where
             ++       \spad{= 1  if i = j}
             ++       \spad{= 0 if  i \^= j}
             ++ 
-            ++E delta:CartesianTensor(1,2,Integer):=kroneckerDelta()
+            ++X delta:CartesianTensor(1,2,Integer):=kroneckerDelta()
 
         leviCivitaSymbol: () -> %
             ++ leviCivitaSymbol() is the rank \spad{dim} tensor defined by
@@ -1276,15 +1276,15 @@ CartesianTensor(minix, dim, R): Exports == Implementation where
             ++ if \spad{i1,...,idim} is an even/is nota /is an odd permutation
             ++ of \spad{minix,...,minix+dim-1}.
             ++ 
-            ++E lcs:CartesianTensor(1,2,Integer):=leviCivitaSymbol()
+            ++X lcs:CartesianTensor(1,2,Integer):=leviCivitaSymbol()
 
         ravel:     % -> List R
             ++ ravel(t) produces a list of components from a tensor such that
             ++   \spad{unravel(ravel(t)) = t}.
             ++ 
-            ++E n:SquareMatrix(2,Integer):=matrix [[2,3],[0,1]]
-            ++E tn:CartesianTensor(1,2,Integer):=n
-            ++E ravel tn
+            ++X n:SquareMatrix(2,Integer):=matrix [[2,3],[0,1]]
+            ++X tn:CartesianTensor(1,2,Integer):=n
+            ++X ravel tn
 
         unravel:   List R -> %
             ++ unravel(t) produces a tensor from a list of
diff --git a/src/algebra/curve.spad.pamphlet b/src/algebra/curve.spad.pamphlet
index 6128b6b..d0b44da 100644
--- a/src/algebra/curve.spad.pamphlet
+++ b/src/algebra/curve.spad.pamphlet
@@ -37,42 +37,42 @@ FunctionFieldCategory(F, UP, UPUP): Category == Definition where
       ++ numberOfComponents() returns the number of absolutely irreducible
       ++ components.
       ++
-      ++E P0 := UnivariatePolynomial(x, Integer)
-      ++E P1 := UnivariatePolynomial(y, Fraction P0)
-      ++E R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
-      ++E numberOfComponents()$R
+      ++X P0 := UnivariatePolynomial(x, Integer)
+      ++X P1 := UnivariatePolynomial(y, Fraction P0)
+      ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
+      ++X numberOfComponents()$R
     genus                  : () -> NonNegativeInteger
       ++ genus() returns the genus of one absolutely irreducible component
       ++
-      ++E P0 := UnivariatePolynomial(x, Integer)
-      ++E P1 := UnivariatePolynomial(y, Fraction P0)
-      ++E R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
-      ++E genus()$R
+      ++X P0 := UnivariatePolynomial(x, Integer)
+      ++X P1 := UnivariatePolynomial(y, Fraction P0)
+      ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
+      ++X genus()$R
     absolutelyIrreducible? : () -> Boolean
       ++ absolutelyIrreducible?() tests if the curve absolutely irreducible?
       ++
-      ++E P0 := UnivariatePolynomial(x, Integer)
-      ++E P1 := UnivariatePolynomial(y, Fraction P0)
-      ++E R2 := RadicalFunctionField(INT, P0, P1, 2 * x**2, 4)
-      ++E absolutelyIrreducible?()$R2
+      ++X P0 := UnivariatePolynomial(x, Integer)
+      ++X P1 := UnivariatePolynomial(y, Fraction P0)
+      ++X R2 := RadicalFunctionField(INT, P0, P1, 2 * x**2, 4)
+      ++X absolutelyIrreducible?()$R2
     rationalPoint?         : (F, F) -> Boolean
       ++ rationalPoint?(a, b) tests if \spad{(x=a,y=b)} is on the curve.
       ++
-      ++E P0 := UnivariatePolynomial(x, Integer)
-      ++E P1 := UnivariatePolynomial(y, Fraction P0)
-      ++E R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
-      ++E rationalPoint?(0,0)$R
-      ++E R2 := RadicalFunctionField(INT, P0, P1, 2 * x**2, 4)
-      ++E rationalPoint?(0,0)$R2
+      ++X P0 := UnivariatePolynomial(x, Integer)
+      ++X P1 := UnivariatePolynomial(y, Fraction P0)
+      ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
+      ++X rationalPoint?(0,0)$R
+      ++X R2 := RadicalFunctionField(INT, P0, P1, 2 * x**2, 4)
+      ++X rationalPoint?(0,0)$R2
     branchPointAtInfinity? : () -> Boolean
       ++ branchPointAtInfinity?() tests if there is a branch point at infinity.
       ++
-      ++E P0 := UnivariatePolynomial(x, Integer)
-      ++E P1 := UnivariatePolynomial(y, Fraction P0)
-      ++E R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
-      ++E branchPointAtInfinity?()$R
-      ++E R2 := RadicalFunctionField(INT, P0, P1, 2 * x**2, 4)
-      ++E branchPointAtInfinity?()$R
+      ++X P0 := UnivariatePolynomial(x, Integer)
+      ++X P1 := UnivariatePolynomial(y, Fraction P0)
+      ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
+      ++X branchPointAtInfinity?()$R
+      ++X R2 := RadicalFunctionField(INT, P0, P1, 2 * x**2, 4)
+      ++X branchPointAtInfinity?()$R
     branchPoint?           : F -> Boolean
       ++ branchPoint?(a) tests whether \spad{x = a} is a branch point.
     branchPoint?           : UP -> Boolean
@@ -92,17 +92,17 @@ FunctionFieldCategory(F, UP, UPUP): Category == Definition where
     integralBasis          : () -> Vector $
       ++ integralBasis() returns the integral basis for the curve.
       ++
-      ++E P0 := UnivariatePolynomial(x, Integer)
-      ++E P1 := UnivariatePolynomial(y, Fraction P0)
-      ++E R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
-      ++E integralBasis()$R
+      ++X P0 := UnivariatePolynomial(x, Integer)
+      ++X P1 := UnivariatePolynomial(y, Fraction P0)
+      ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
+      ++X integralBasis()$R
     integralBasisAtInfinity: () -> Vector $
       ++ integralBasisAtInfinity() returns the local integral basis at infinity
       ++
-      ++E P0 := UnivariatePolynomial(x, Integer)
-      ++E P1 := UnivariatePolynomial(y, Fraction P0)
-      ++E R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
-      ++E integralBasisAtInfinity()$R
+      ++X P0 := UnivariatePolynomial(x, Integer)
+      ++X P1 := UnivariatePolynomial(y, Fraction P0)
+      ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
+      ++X integralBasisAtInfinity()$R
     integralAtInfinity?    : $  -> Boolean
       ++ integralAtInfinity?() tests if f is locally integral at infinity.
     integral?              : $  -> Boolean
@@ -121,40 +121,40 @@ FunctionFieldCategory(F, UP, UPUP): Category == Definition where
       ++ where \spad{(w1,...,wn)} is the integral basis of
       ++ \spadfunFrom{integralBasis}{FunctionFieldCategory}.
       ++
-      ++E P0 := UnivariatePolynomial(x, Integer)
-      ++E P1 := UnivariatePolynomial(y, Fraction P0)
-      ++E R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
-      ++E integralMatrix()$R
+      ++X P0 := UnivariatePolynomial(x, Integer)
+      ++X P1 := UnivariatePolynomial(y, Fraction P0)
+      ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
+      ++X integralMatrix()$R
     inverseIntegralMatrix  : () -> Matrix RF
       ++ inverseIntegralMatrix() returns M such that
       ++ \spad{M (w1,...,wn) = (1, y, ..., y**(n-1))}
       ++ where \spad{(w1,...,wn)} is the integral basis of
       ++ \spadfunFrom{integralBasis}{FunctionFieldCategory}.
       ++
-      ++E P0 := UnivariatePolynomial(x, Integer)
-      ++E P1 := UnivariatePolynomial(y, Fraction P0)
-      ++E R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
-      ++E inverseIntegralMatrix()$R
+      ++X P0 := UnivariatePolynomial(x, Integer)
+      ++X P1 := UnivariatePolynomial(y, Fraction P0)
+      ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
+      ++X inverseIntegralMatrix()$R
     integralMatrixAtInfinity       : () -> Matrix RF
       ++ integralMatrixAtInfinity() returns M such that
       ++ \spad{(v1,...,vn) = M (1, y, ..., y**(n-1))}
       ++ where \spad{(v1,...,vn)} is the local integral basis at infinity
       ++ returned by \spad{infIntBasis()}.
       ++
-      ++E P0 := UnivariatePolynomial(x, Integer)
-      ++E P1 := UnivariatePolynomial(y, Fraction P0)
-      ++E R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
-      ++E integralMatrixAtInfinity()$R
+      ++X P0 := UnivariatePolynomial(x, Integer)
+      ++X P1 := UnivariatePolynomial(y, Fraction P0)
+      ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
+      ++X integralMatrixAtInfinity()$R
     inverseIntegralMatrixAtInfinity: () -> Matrix RF
       ++ inverseIntegralMatrixAtInfinity() returns M such
       ++ that \spad{M (v1,...,vn) = (1, y, ..., y**(n-1))}
       ++ where \spad{(v1,...,vn)} is the local integral basis at infinity
       ++ returned by \spad{infIntBasis()}.
       ++
-      ++E P0 := UnivariatePolynomial(x, Integer)
-      ++E P1 := UnivariatePolynomial(y, Fraction P0)
-      ++E R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
-      ++E inverseIntegralMatrixAtInfinity()$R
+      ++X P0 := UnivariatePolynomial(x, Integer)
+      ++X P1 := UnivariatePolynomial(y, Fraction P0)
+      ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20)
+      ++X inverseIntegralMatrixAtInfinity()$R
     yCoordinates           : $ -> Record(num:Vector(UP), den:UP)
       ++ yCoordinates(f) returns \spad{[[A1,...,An], D]} such that
       ++ \spad{f = (A1 + A2 y +...+ An y**(n-1)) / D}.
diff --git a/src/algebra/fr.spad.pamphlet b/src/algebra/fr.spad.pamphlet
index 8c4c8f0..d03f159 100644
--- a/src/algebra/fr.spad.pamphlet
+++ b/src/algebra/fr.spad.pamphlet
@@ -675,38 +675,38 @@ Factored(R: IntegralDomain): Exports == Implementation where
     ++ \spadfun{coerce} which would cause the interpreter to do this 
     ++ automatically.
     ++
-    ++E f:=nilFactor(y-x,3)
-    ++E expand(f)
+    ++X f:=nilFactor(y-x,3)
+    ++X expand(f)
 
    exponent:  % -> Integer
     ++ exponent(u) returns the exponent of the first factor of
     ++ \spadvar{u}, or 0 if the factored form consists solely of a unit.
     ++
-    ++E f:=nilFactor(y-x,3)
-    ++E exponent(f)
+    ++X f:=nilFactor(y-x,3)
+    ++X exponent(f)
 
    makeFR  : (R, List FF) -> %
     ++ makeFR(unit,listOfFactors) creates a factored object (for
     ++ use by factoring code).
     ++
-    ++E f:=nilFactor(x-y,3)
-    ++E g:=factorList f
-    ++E makeFR(z,g)
+    ++X f:=nilFactor(x-y,3)
+    ++X g:=factorList f
+    ++X makeFR(z,g)
 
    factorList : % -> List FF
     ++ factorList(u) returns the list of factors with flags (for
     ++ use by factoring code).
     ++
-    ++E f:=nilFactor(x-y,3)
-    ++E factorList f
+    ++X f:=nilFactor(x-y,3)
+    ++X factorList f
 
    nilFactor: (R, Integer) -> %
     ++ nilFactor(base,exponent) creates a factored object with
     ++ a single factor with no information about the kind of
     ++ base (flag = "nil").
     ++
-    ++E nilFactor(24,2)
-    ++E nilFactor(x-y,3)
+    ++X nilFactor(24,2)
+    ++X nilFactor(x-y,3)
 
    factors: % -> List Record(factor:R, exponent:Integer)
     ++ factors(u) returns a list of the factors in a form suitable
@@ -715,26 +715,26 @@ Factored(R: IntegralDomain): Exports == Implementation where
     ++ object is the product of all the factors and the unit (which
     ++ can be extracted by \axiom{unit(u)}).
     ++
-    ++E f:=x*y^3-3*x^2*y^2+3*x^3*y-x^4
-    ++E factors f
-    ++E g:=makeFR(z,factorList f)
-    ++E factors g
+    ++X f:=x*y^3-3*x^2*y^2+3*x^3*y-x^4
+    ++X factors f
+    ++X g:=makeFR(z,factorList f)
+    ++X factors g
 
    irreducibleFactor: (R, Integer) -> %
     ++ irreducibleFactor(base,exponent) creates a factored object with
     ++ a single factor whose base is asserted to be irreducible
     ++ (flag = "irred").
     ++
-    ++E a:=irreducibleFactor(3,1)
-    ++E nthFlag(a,1)
+    ++X a:=irreducibleFactor(3,1)
+    ++X nthFlag(a,1)
 
    nthExponent: (%, Integer) -> Integer
     ++ nthExponent(u,n) returns the exponent of the nth factor of
     ++ \spadvar{u}.  If \spadvar{n} is not a valid index for a factor
     ++ (for example, less than 1 or too big), 0 is returned.
     ++
-    ++E a:=factor 9720000
-    ++E nthExponent(a,2)
+    ++X a:=factor 9720000
+    ++X nthExponent(a,2)
 
    nthFactor:  (%,Integer) -> R
     ++ nthFactor(u,n) returns the base of the nth factor of
@@ -742,38 +742,38 @@ Factored(R: IntegralDomain): Exports == Implementation where
     ++ (for example, less than 1 or too big), 1 is returned.  If
     ++ \spadvar{u} consists only of a unit, the unit is returned.
     ++
-    ++E a:=factor 9720000
-    ++E nthFactor(a,2)
+    ++X a:=factor 9720000
+    ++X nthFactor(a,2)
 
    nthFlag:    (%,Integer) -> fUnion
     ++ nthFlag(u,n) returns the information flag of the nth factor of
     ++ \spadvar{u}.  If \spadvar{n} is not a valid index for a factor
     ++ (for example, less than 1 or too big), "nil" is returned.
     ++
-    ++E a:=factor 9720000
-    ++E nthFlag(a,2)
+    ++X a:=factor 9720000
+    ++X nthFlag(a,2)
 
    numberOfFactors : %  -> NonNegativeInteger
     ++ numberOfFactors(u) returns the number of factors in \spadvar{u}.
     ++
-    ++E a:=factor 9720000
-    ++E numberOfFactors a
+    ++X a:=factor 9720000
+    ++X numberOfFactors a
 
    primeFactor:   (R,Integer) -> %
     ++ primeFactor(base,exponent) creates a factored object with
     ++ a single factor whose base is asserted to be prime
     ++ (flag = "prime").
     ++
-    ++E a:=primeFactor(3,4)
-    ++E nthFlag(a,1)
+    ++X a:=primeFactor(3,4)
+    ++X nthFlag(a,1)
 
    sqfrFactor:   (R,Integer) -> %
     ++ sqfrFactor(base,exponent) creates a factored object with
     ++ a single factor whose base is asserted to be square-free
     ++ (flag = "sqfr").
     ++
-    ++E a:=sqfrFactor(3,5)
-    ++E nthFlag(a,1)
+    ++X a:=sqfrFactor(3,5)
+    ++X nthFlag(a,1)
 
    flagFactor: (R,Integer, fUnion) -> %
     ++ flagFactor(base,exponent,flag) creates a factored object with
@@ -783,10 +783,10 @@ Factored(R: IntegralDomain): Exports == Implementation where
    unit:    % -> R
     ++ unit(u) extracts the unit part of the factorization.
     ++
-    ++E f:=x*y^3-3*x^2*y^2+3*x^3*y-x^4
-    ++E unit f
-    ++E g:=makeFR(z,factorList f)
-    ++E unit g
+    ++X f:=x*y^3-3*x^2*y^2+3*x^3*y-x^4
+    ++X unit f
+    ++X g:=makeFR(z,factorList f)
+    ++X unit g
 
    unitNormalize: % -> %
     ++ unitNormalize(u) normalizes the unit part of the factorization.
@@ -799,11 +799,11 @@ Factored(R: IntegralDomain): Exports == Implementation where
     ++ the information flags (sets them to "nil") because the effect of
     ++ \userfun{fn} is clearly not known in general.
     ++
-    ++E m(a:Factored Polynomial Integer):Factored Polynomial Integer == a^2
-    ++E f:=x*y^3-3*x^2*y^2+3*x^3*y-x^4
-    ++E map(m,f)
-    ++E g:=makeFR(z,factorList f)
-    ++E map(m,g)
+    ++X m(a:Factored Polynomial Integer):Factored Polynomial Integer == a^2
+    ++X f:=x*y^3-3*x^2*y^2+3*x^3*y-x^4
+    ++X map(m,f)
+    ++X g:=makeFR(z,factorList f)
+    ++X map(m,g)
 
     -- the following operations are conditional on R
 
diff --git a/src/algebra/listgcd.spad.pamphlet b/src/algebra/listgcd.spad.pamphlet
index 8cbcebe..8c74a22 100644
--- a/src/algebra/listgcd.spad.pamphlet
+++ b/src/algebra/listgcd.spad.pamphlet
@@ -35,8 +35,8 @@ HeuGcd (BP):C == T
      gcd          : List BP  -> BP
        ++ gcd([f1,..,fk]) = gcd of the polynomials fi.
        ++
-       ++E gcd([671*671*x^2-1,671*671*x^2+2*671*x+1])
-       ++E gcd([7*x^2+1,(7*x^2+1)^2])
+       ++X gcd([671*671*x^2-1,671*671*x^2+2*671*x+1])
+       ++X gcd([7*x^2+1,(7*x^2+1)^2])
 
      gcdprim      : List BP  -> BP
        ++ gcdprim([f1,..,fk]) = gcd of k PRIMITIVE univariate polynomials
diff --git a/src/algebra/mappkg.spad.pamphlet b/src/algebra/mappkg.spad.pamphlet
index ca1dc5f..030d679 100644
--- a/src/algebra/mappkg.spad.pamphlet
+++ b/src/algebra/mappkg.spad.pamphlet
@@ -1783,28 +1783,28 @@ MappingPackage4(A:SetCategory, B:Ring):
    "+": (A->B, A->B) -> (A->B) 
         ++ \spad(+) does functional addition
         ++
-        ++E f:=(x:INT):INT +-> 3*x
-        ++E g:=(x:INT):INT +-> 2*x+3
-        ++E (f+g)(4)
+        ++X f:=(x:INT):INT +-> 3*x
+        ++X g:=(x:INT):INT +-> 2*x+3
+        ++X (f+g)(4)
    "-": (A->B, A->B) -> (A->B) 
         ++ \spad(+) does functional addition
         ++
-        ++E f:=(x:INT):INT +-> 3*x
-        ++E g:=(x:INT):INT +-> 2*x+3
-        ++E (f-g)(4)
+        ++X f:=(x:INT):INT +-> 3*x
+        ++X g:=(x:INT):INT +-> 2*x+3
+        ++X (f-g)(4)
    "*": (A->B, A->B) -> (A->B) 
         ++ \spad(+) does functional addition
         ++
-        ++E f:=(x:INT):INT +-> 3*x
-        ++E g:=(x:INT):INT +-> 2*x+3
-        ++E (f*g)(4)
+        ++X f:=(x:INT):INT +-> 3*x
+        ++X g:=(x:INT):INT +-> 2*x+3
+        ++X (f*g)(4)
    "/": (A->Expression(Integer), A->Expression(Integer)) -> (A->Expression(Integer))
         ++ \spad(+) does functional addition
         ++
-        ++E p:=(x:EXPR(INT)):EXPR(INT)+->3*x
-        ++E q:=(x:EXPR(INT)):EXPR(INT)+->2*x+3
-        ++E (p/q)(4)
-        ++E (p/q)(x)
+        ++X p:=(x:EXPR(INT)):EXPR(INT)+->3*x
+        ++X q:=(x:EXPR(INT)):EXPR(INT)+->2*x+3
+        ++X (p/q)(4)
+        ++X (p/q)(x)
   == add
     fab ==> (A -> B)
     faei ==> (A -> Expression(Integer))
diff --git a/src/algebra/mkfunc.spad.pamphlet b/src/algebra/mkfunc.spad.pamphlet
index 840aa2e..6a34b58 100644
--- a/src/algebra/mkfunc.spad.pamphlet
+++ b/src/algebra/mkfunc.spad.pamphlet
@@ -34,8 +34,8 @@ InputForm():
       ++ \spad{binary(op, [a1,...,an])} returns the input form
       ++ corresponding to  \spad{a1 op a2 op ... op an}.
       ++
-      ++E a:=[1,2,3]::List(InputForm)
-      ++E binary(_+::InputForm,a)
+      ++X a:=[1,2,3]::List(InputForm)
+      ++X binary(_+::InputForm,a)
 
     function : (%, List Symbol, Symbol) -> %
       ++ \spad{function(code, [x1,...,xn], f)} returns the input form
diff --git a/src/algebra/plot.spad.pamphlet b/src/algebra/plot.spad.pamphlet
index 81c4846..4c9ed69 100644
--- a/src/algebra/plot.spad.pamphlet
+++ b/src/algebra/plot.spad.pamphlet
@@ -146,8 +146,8 @@ Plot(): Exports == Implementation where
       ++ plot(f,a..b) plots the function \spad{f(x)} 
       ++ on the interval \spad{[a,b]}.
       ++ 
-      ++E fp:=(t:DFLOAT):DFLOAT +-> sin(t)
-      ++E plot(fp,-1.0..1.0)$PLOT
+      ++X fp:=(t:DFLOAT):DFLOAT +-> sin(t)
+      ++X plot(fp,-1.0..1.0)$PLOT
 
     plot: (F -> F,R,R) -> %
       ++ plot(f,a..b,c..d) plots the function \spad{f(x)} on the interval
diff --git a/src/algebra/radix.spad.pamphlet b/src/algebra/radix.spad.pamphlet
index 28185f1..06bb6b8 100644
--- a/src/algebra/radix.spad.pamphlet
+++ b/src/algebra/radix.spad.pamphlet
@@ -724,7 +724,7 @@ BinaryExpansion(): Exports == Implementation where
     binary: Fraction Integer -> %
       ++ binary(r) converts a rational number to a binary expansion.
       ++
-      ++E binary(22/7)
+      ++X binary(22/7)
 
   Implementation ==> RadixExpansion(2) add
     binary r == r :: %
diff --git a/src/algebra/stream.spad.pamphlet b/src/algebra/stream.spad.pamphlet
index d69cbfb..e30e3b4 100644
--- a/src/algebra/stream.spad.pamphlet
+++ b/src/algebra/stream.spad.pamphlet
@@ -30,40 +30,40 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with
     ++ st which do not satisfy the predicate f.
     ++ Note: \spad{remove(f,st) = [x for x in st | not f(x)]}.
     ++
-    ++E m:=[i for i in 1..]
-    ++E f(i:PositiveInteger):Boolean == even? i
-    ++E remove(f,m)
+    ++X m:=[i for i in 1..]
+    ++X f(i:PositiveInteger):Boolean == even? i
+    ++X remove(f,m)
 
   select: (S -> Boolean,%) -> %
     ++ select(f,st) returns a stream consisting of those elements of stream
     ++ st satisfying the predicate f.
     ++ Note: \spad{select(f,st) = [x for x in st | f(x)]}.
     ++
-    ++E m:=[i for i in 0..]
-    ++E select(x+->prime? x,m)
+    ++X m:=[i for i in 0..]
+    ++X select(x+->prime? x,m)
 
   explicitEntries?: % -> Boolean
     ++ explicitEntries?(s) returns true if the stream s has
     ++ explicitly computed entries, and false otherwise.
     ++
-    ++E m:=[i for i in 0..]
-    ++E explicitEntries? m
+    ++X m:=[i for i in 0..]
+    ++X explicitEntries? m
 
   explicitlyEmpty?: % -> Boolean
     ++ explicitlyEmpty?(s) returns true if the stream is an
     ++ (explicitly) empty stream.
     ++ Note: this is a null test which will not cause lazy evaluation.
     ++
-    ++E m:=[i for i in 0..]
-    ++E explicitlyEmpty? m
+    ++X m:=[i for i in 0..]
+    ++X explicitlyEmpty? m
 
   lazy?: % -> Boolean
     ++ lazy?(s) returns true if the first node of the stream s
     ++ is a lazy evaluation mechanism which could produce an
     ++ additional entry to s.
     ++
-    ++E m:=[i for i in 0..]
-    ++E lazy? m
+    ++X m:=[i for i in 0..]
+    ++X lazy? m
 
   lazyEvaluate: % -> %
     ++ lazyEvaluate(s) causes one lazy evaluation of stream s.
@@ -76,24 +76,24 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with
     ++ Caution: this function should only be called after a \spad{empty?} test
     ++ has been made since there no error check.
     ++
-    ++E m:=[i for i in 0..]
-    ++E frst m
+    ++X m:=[i for i in 0..]
+    ++X frst m
 
   rst: % -> %
     ++ rst(s) returns a pointer to the next node of stream s.
     ++ Caution: this function should only be called after a \spad{empty?} test
     ++ has been made since there no error check.
     ++
-    ++E m:=[i for i in 0..]
-    ++E rst m
+    ++X m:=[i for i in 0..]
+    ++X rst m
 
   numberOfComputedEntries: % -> NonNegativeInteger
     ++ numberOfComputedEntries(st) returns the number of explicitly
     ++ computed entries of stream st which exist immediately prior to the time
     ++ this function is called.
     ++
-    ++E m:=[i for i in 0..]
-    ++E numberOfComputedEntries m
+    ++X m:=[i for i in 0..]
+    ++X numberOfComputedEntries m
 
   extend: (%,Integer) -> %
     ++ extend(st,n) causes entries to be computed, if necessary,
@@ -101,21 +101,21 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with
     ++ that all entries of 'st' will be computed if 'st' is finite
     ++ with length <= n.
     ++
-    ++E m:=[i for i in 0..]
-    ++E numberOfComputedEntries m
-    ++E extend(m,20)
-    ++E numberOfComputedEntries m
+    ++X m:=[i for i in 0..]
+    ++X numberOfComputedEntries m
+    ++X extend(m,20)
+    ++X numberOfComputedEntries m
 
   complete: % -> %
     ++ complete(st) causes all entries of 'st' to be computed.
     ++ this function should only be called on streams which are
     ++ known to be finite.
     ++
-    ++E m:=[i for i in 1..]
-    ++E n:=filterUntil(i+->i>100,m)
-    ++E numberOfComputedEntries n
-    ++E complete n
-    ++E numberOfComputedEntries n
+    ++X m:=[i for i in 1..]
+    ++X n:=filterUntil(i+->i>100,m)
+    ++X numberOfComputedEntries n
+    ++X complete n
+    ++X numberOfComputedEntries n
 
  add
 
@@ -551,29 +551,29 @@ CyclicStreamTools(S,ST): Exports == Implementation where
       ++ cycleElt(s) returns a pointer to a node in the cycle if the stream 
       ++ s is cyclic and returns "failed" if s is not cyclic
       ++
-      ++E p:=repeating([1,2,3])
-      ++E q:=cons(4,p)
-      ++E cycleElt q
-      ++E r:=[1,2,3]::Stream(Integer)
-      ++E cycleElt r
+      ++X p:=repeating([1,2,3])
+      ++X q:=cons(4,p)
+      ++X cycleElt q
+      ++X r:=[1,2,3]::Stream(Integer)
+      ++X cycleElt r
 
     computeCycleLength: ST -> NonNegativeInteger
       ++ computeCycleLength(s) returns the length of the cycle of a
       ++ cyclic stream t, where s is a pointer to a node in the
       ++ cyclic part of t.
       ++
-      ++E p:=repeating([1,2,3])
-      ++E q:=cons(4,p)
-      ++E computeCycleLength(cycleElt(q))
+      ++X p:=repeating([1,2,3])
+      ++X q:=cons(4,p)
+      ++X computeCycleLength(cycleElt(q))
 
     computeCycleEntry: (ST,ST) -> ST
       ++ computeCycleEntry(x,cycElt), where cycElt is a pointer to a
       ++ node in the cyclic part of the cyclic stream x, returns a
       ++ pointer to the first node in the cycle
       ++
-      ++E p:=repeating([1,2,3])
-      ++E q:=cons(4,p)
-      ++E computeCycleEntry(q,cycleElt(q))
+      ++X p:=repeating([1,2,3])
+      ++X q:=cons(4,p)
+      ++X computeCycleEntry(q,cycleElt(q))
 
   Implementation ==> add
 
@@ -817,31 +817,31 @@ Stream(S): Exports == Implementation where
     coerce: L S -> %
       ++ coerce(l) converts a list l to a stream.
       ++
-      ++E m:=[1,2,3,4,5,6,7,8,9,10,11,12]
-      ++E coerce(m)@Stream(Integer)
-      ++E m::Stream(Integer)
+      ++X m:=[1,2,3,4,5,6,7,8,9,10,11,12]
+      ++X coerce(m)@Stream(Integer)
+      ++X m::Stream(Integer)
 
     repeating: L S -> %
       ++ repeating(l) is a repeating stream whose period is the list l.
       ++
-      ++E m:=repeating([-1,0,1,2,3])
+      ++X m:=repeating([-1,0,1,2,3])
 
     if S has SetCategory then
       repeating?: (L S,%) -> B
         ++ repeating?(l,s) returns true if a stream s is periodic
         ++ with period l, and false otherwise.
         ++
-        ++E m:=[1,2,3]
-        ++E n:=repeating(m)
-        ++E repeating?(m,n)
+        ++X m:=[1,2,3]
+        ++X n:=repeating(m)
+        ++X repeating?(m,n)
 
     findCycle: (NNI,%) -> Record(cycle?: B, prefix: NNI, period: NNI)
       ++ findCycle(n,st) determines if st is periodic within n.
       ++
-      ++E m:=[1,2,3]
-      ++E n:=repeating(m)
-      ++E findCycle(3,n)
-      ++E findCycle(2,n)
+      ++X m:=[1,2,3]
+      ++X n:=repeating(m)
+      ++X findCycle(3,n)
+      ++X findCycle(2,n)
 
     delay: (() -> %) -> %
       ++ delay(f) creates a stream with a lazy evaluation defined by 
@@ -852,26 +852,26 @@ Stream(S): Exports == Implementation where
       ++ and whose \spad{rest} is s.
       ++ Note: \spad{cons(a,s) = concat(a,s)}.
       ++
-      ++E m:=[1,2,3]
-      ++E n:=repeating(m)
-      ++E cons(4,n)
+      ++X m:=[1,2,3]
+      ++X n:=repeating(m)
+      ++X cons(4,n)
 
     if S has SetCategory then
       output: (I, %) -> Void
         ++ output(n,st) computes and displays the first n entries
         ++ of st.
         ++
-        ++E m:=[1,2,3]
-        ++E n:=repeating(m)
-        ++E output(5,n)
+        ++X m:=[1,2,3]
+        ++X n:=repeating(m)
+        ++X output(5,n)
 
       showAllElements: % -> OUT
         ++ showAllElements(s) creates an output form which displays all
         ++ computed elements.
         ++
-        ++E m:=[1,2,3,4,5,6,7,8,9,10,11,12]
-        ++E n:=m::Stream(PositiveInteger)
-        ++E showAllElements n
+        ++X m:=[1,2,3,4,5,6,7,8,9,10,11,12]
+        ++X n:=m::Stream(PositiveInteger)
+        ++X showAllElements n
 
       showAll?: () -> B
         ++ showAll?() returns true if all computed entries of streams
@@ -881,44 +881,44 @@ Stream(S): Exports == Implementation where
       ++ setrest!(x,n,y) sets rest(x,n) to y. The function will expand
       ++ cycles if necessary.
       ++
-      ++E p:=[i for i in 1..]
-      ++E q:=[i for i in 9..]
-      ++E setrest!(p,4,q)
-      ++E p
+      ++X p:=[i for i in 1..]
+      ++X q:=[i for i in 9..]
+      ++X setrest!(p,4,q)
+      ++X p
 
     generate: (() -> S) -> %
       ++ generate(f) creates an infinite stream all of whose elements are
       ++ equal to \spad{f()}.
       ++ Note: \spad{generate(f) = [f(),f(),f(),...]}.
       ++
-      ++E f():Integer == 1
-      ++E generate(f)
+      ++X f():Integer == 1
+      ++X generate(f)
 
     generate: (S -> S,S) -> %
       ++ generate(f,x) creates an infinite stream whose first element is
       ++ x and whose nth element (\spad{n > 1}) is f applied to the previous
       ++ element. Note: \spad{generate(f,x) = [x,f(x),f(f(x)),...]}.
       ++
-      ++E f(x:Integer):Integer == x+10
-      ++E generate(f,10)
+      ++X f(x:Integer):Integer == x+10
+      ++X generate(f,10)
 
     filterWhile: (S -> Boolean,%) -> %
       ++ filterWhile(p,s) returns \spad{[x0,x1,...,x(n-1)]} where
       ++ \spad{s = [x0,x1,x2,..]} and
       ++ n is the smallest index such that \spad{p(xn) = false}.
       ++
-      ++E m:=[i for i in 1..]
-      ++E f(x:PositiveInteger):Boolean ==  x < 5
-      ++E filterWhile(f,m)
+      ++X m:=[i for i in 1..]
+      ++X f(x:PositiveInteger):Boolean ==  x < 5
+      ++X filterWhile(f,m)
 
     filterUntil: (S -> Boolean,%) -> %
       ++ filterUntil(p,s) returns \spad{[x0,x1,...,x(n)]} where
       ++ \spad{s = [x0,x1,x2,..]} and
       ++ n is the smallest index such that \spad{p(xn) = true}.
       ++
-      ++E m:=[i for i in 1..]
-      ++E f(x:PositiveInteger):Boolean ==  x < 5
-      ++E filterUntil(f,m)
+      ++X m:=[i for i in 1..]
+      ++X f(x:PositiveInteger):Boolean ==  x < 5
+      ++X filterUntil(f,m)
 
 --    if S has SetCategory then
 --      map: ((S,S) -> S,%,%,S) -> %
@@ -1446,10 +1446,10 @@ StreamFunctions1(S:Type): Exports == Implementation where
       ++ concat(u) returns the left-to-right concatentation of the 
       ++ streams in u. Note: \spad{concat(u) = reduce(concat,u)}.
       ++
-      ++E m:=[i for i in 10..]
-      ++E n:=[j for j in 1.. | prime? j]
-      ++E p:=[m,n]::Stream(Stream(PositiveInteger))
-      ++E concat(p)
+      ++X m:=[i for i in 10..]
+      ++X n:=[j for j in 1.. | prime? j]
+      ++X p:=[m,n]::Stream(Stream(PositiveInteger))
+      ++X concat(p)
 
   Implementation ==> add
 
@@ -1476,9 +1476,9 @@ StreamFunctions2(A:Type,B:Type): Exports == Implementation where
       ++ to the corresponding elements of s.
       ++ Note: \spad{map(f,[x0,x1,x2,...]) = [f(x0),f(x1),f(x2),..]}.
       ++
-      ++E m:=[i for i in 1..]
-      ++E f(i:PositiveInteger):PositiveInteger==i**2
-      ++E map(f,m)
+      ++X m:=[i for i in 1..]
+      ++X f(i:PositiveInteger):PositiveInteger==i**2
+      ++X map(f,m)
 
     scan: (B,((A,B) -> B),ST A) -> ST B
       ++ scan(b,h,[x0,x1,x2,...]) returns \spad{[y0,y1,y2,...]}, where
@@ -1486,9 +1486,9 @@ StreamFunctions2(A:Type,B:Type): Exports == Implementation where
       ++ \spad{y1 = h(x1,y0)},\spad{...}
       ++ \spad{yn = h(xn,y(n-1))}.
       ++
-      ++E m:=[i for i in 1..]::Stream(Integer)
-      ++E f(i:Integer,j:Integer):Integer==i+j
-      ++E scan(1,f,m)
+      ++X m:=[i for i in 1..]::Stream(Integer)
+      ++X f(i:Integer,j:Integer):Integer==i+j
+      ++X scan(1,f,m)
 
     reduce:  (B,(A,B) -> B,ST A) -> B
       ++ reduce(b,f,u), where u is a finite stream \spad{[x0,x1,...,xn]},
@@ -1497,9 +1497,9 @@ StreamFunctions2(A:Type,B:Type): Exports == Implementation where
       ++ r1 = f(x1,r0),...,
       ++ r(n) = f(xn,r(n-1))}.
       ++
-      ++E m:=[i for i in 1..300]::Stream(Integer)
-      ++E f(i:Integer,j:Integer):Integer==i+j
-      ++E reduce(1,f,m)
+      ++X m:=[i for i in 1..300]::Stream(Integer)
+      ++X f(i:Integer,j:Integer):Integer==i+j
+      ++X reduce(1,f,m)
 
 --  rreduce: (B,(A,B) -> B,ST A) -> B
 --    ++ reduce(b,h,[x0,x1,..,xn]) = h(x1,h(x2(..,h(x(n-1),h(xn,b))..)
@@ -1554,10 +1554,10 @@ StreamFunctions3(A,B,C): Exports == Implementation where
       ++ \spad{map(f,[x0,x1,x2,..],[y0,y1,y2,..]) = [f(x0,y0),f(x1,y1),..]}.
       ++
       ++S
-      ++E m:=[i for i in 1..]::Stream(Integer)
-      ++E n:=[i for i in 1..]::Stream(Integer)
-      ++E f(i:Integer,j:Integer):Integer == i+j
-      ++E map(f,m,n)
+      ++X m:=[i for i in 1..]::Stream(Integer)
+      ++X n:=[i for i in 1..]::Stream(Integer)
+      ++X f(i:Integer,j:Integer):Integer == i+j
+      ++X map(f,m,n)
 
   Implementation ==> add
 
diff --git a/src/algebra/string.spad.pamphlet b/src/algebra/string.spad.pamphlet
index 9cae78b..8ee1e1b 100644
--- a/src/algebra/string.spad.pamphlet
+++ b/src/algebra/string.spad.pamphlet
@@ -232,81 +232,81 @@ Character: OrderedFinite() with
     ++ ord(c) provides an integral code corresponding to the
     ++ character c.  It is always true that \spad{char ord c = c}.
     ++
-    ++E chars := [char "a", char "A", char "X", char "8", char "+"]
-    ++E [ord c for c in chars]
+    ++X chars := [char "a", char "A", char "X", char "8", char "+"]
+    ++X [ord c for c in chars]
   char: Integer  -> %
     ++ char(i) provides a character corresponding to the integer
     ++ code i. It is always true that \spad{ord char i = i}.
     ++
-    ++E [char c for c in [97,65,88,56,43]]
+    ++X [char c for c in [97,65,88,56,43]]
   char: String   -> %
     ++ char(s) provides a character from a string s of length one.
     ++
-    ++E [char c for c in ["a","A","X","8","+"]]
+    ++X [char c for c in ["a","A","X","8","+"]]
   space: () -> %
     ++ space() provides the blank character.
     ++
-    ++E space()
+    ++X space()
   quote: () -> %
     ++ quote() provides the string quote character, \spad{"}.
     ++
-    ++E quote()
+    ++X quote()
   escape: () -> %
     ++ escape() provides the escape character, \spad{_}, which
     ++ is used to allow quotes and other characters {\em within}
     ++ strings.
     ++
-    ++E escape()
+    ++X escape()
   upperCase: % -> %
     ++ upperCase(c) converts a lower case letter to the corresponding
     ++ upper case letter.  If c is not a lower case letter, then
     ++ it is returned unchanged.
     ++
-    ++E chars := [char "a", char "A", char "X", char "8", char "+"]
-    ++E [upperCase c for c in chars]
+    ++X chars := [char "a", char "A", char "X", char "8", char "+"]
+    ++X [upperCase c for c in chars]
   lowerCase: % -> %
     ++ lowerCase(c) converts an upper case letter to the corresponding
     ++ lower case letter.  If c is not an upper case letter, then
     ++ it is returned unchanged.
     ++
-    ++E chars := [char "a", char "A", char "X", char "8", char "+"]
-    ++E [lowerCase c for c in chars]
+    ++X chars := [char "a", char "A", char "X", char "8", char "+"]
+    ++X [lowerCase c for c in chars]
   digit?: % -> Boolean
     ++ digit?(c) tests if c is a digit character,
     ++ i.e. one of 0..9.
     ++
-    ++E chars := [char "a", char "A", char "X", char "8", char "+"]
-    ++E [digit? c for c in chars]
+    ++X chars := [char "a", char "A", char "X", char "8", char "+"]
+    ++X [digit? c for c in chars]
   hexDigit?: % -> Boolean
     ++ hexDigit?(c) tests if c is a hexadecimal numeral,
     ++ i.e. one of 0..9, a..f or A..F.
     ++
-    ++E chars := [char "a", char "A", char "X", char "8", char "+"]
-    ++E [hexDigit? c for c in chars]
+    ++X chars := [char "a", char "A", char "X", char "8", char "+"]
+    ++X [hexDigit? c for c in chars]
   alphabetic?: % -> Boolean
     ++ alphabetic?(c) tests if c is a letter,
     ++ i.e. one of a..z or A..Z.
     ++
-    ++E chars := [char "a", char "A", char "X", char "8", char "+"]
-    ++E [alphabetic? c for c in chars]
+    ++X chars := [char "a", char "A", char "X", char "8", char "+"]
+    ++X [alphabetic? c for c in chars]
   upperCase?: % -> Boolean
     ++ upperCase?(c) tests if c is an upper case letter,
     ++ i.e. one of A..Z.
     ++
-    ++E chars := [char "a", char "A", char "X", char "8", char "+"]
-    ++E [upperCase? c for c in chars]
+    ++X chars := [char "a", char "A", char "X", char "8", char "+"]
+    ++X [upperCase? c for c in chars]
   lowerCase?: % -> Boolean
     ++ lowerCase?(c) tests if c is an lower case letter,
     ++ i.e. one of a..z.
     ++
-    ++E chars := [char "a", char "A", char "X", char "8", char "+"]
-    ++E [lowerCase? c for c in chars]
+    ++X chars := [char "a", char "A", char "X", char "8", char "+"]
+    ++X [lowerCase? c for c in chars]
   alphanumeric?: % -> Boolean
     ++ alphanumeric?(c) tests if c is either a letter or number,
     ++ i.e. one of 0..9, a..z or A..Z.
     ++
-    ++E chars := [char "a", char "A", char "X", char "8", char "+"]
-    ++E [alphanumeric? c for c in chars]
+    ++X chars := [char "a", char "A", char "X", char "8", char "+"]
+    ++X [alphanumeric? c for c in chars]
 
  == add
 
diff --git a/src/algebra/tree.spad.pamphlet b/src/algebra/tree.spad.pamphlet
index 0a208e0..ab2e87d 100644
--- a/src/algebra/tree.spad.pamphlet
+++ b/src/algebra/tree.spad.pamphlet
@@ -32,50 +32,50 @@ Tree(S: SetCategory): T==C where
      tree: (S,List %) -> %
        ++ tree(nd,ls) creates a tree with value nd, and children ls.
        ++
-       ++E t1:=tree [1,2,3,4]
-       ++E tree(5,[t1])
+       ++X t1:=tree [1,2,3,4]
+       ++X tree(5,[t1])
 
      tree: List S -> %
        ++ tree(ls) creates a tree from a list of elements of s. 
        ++
-       ++E tree [1,2,3,4]
+       ++X tree [1,2,3,4]
 
      tree: S -> %
        ++ tree(nd) creates a tree with value nd, and no children
        ++
-       ++E tree 6
+       ++X tree 6
 
      cyclic?: % -> Boolean
        ++ cyclic?(t) tests if t is a cyclic tree.
        ++
-       ++E t1:=tree [1,2,3,4]
-       ++E cyclic? t1
+       ++X t1:=tree [1,2,3,4]
+       ++X cyclic? t1
 
      cyclicCopy: % -> %
        ++ cyclicCopy(l) makes a copy of a (possibly) cyclic tree l.
        ++
-       ++E t1:=tree [1,2,3,4]
-       ++E cyclicCopy t1
+       ++X t1:=tree [1,2,3,4]
+       ++X cyclicCopy t1
 
      cyclicEntries:    % -> List %
        ++ cyclicEntries(t) returns a list of top-level cycles in tree t.
        ++
-       ++E t1:=tree [1,2,3,4]
-       ++E cyclicEntries t1
+       ++X t1:=tree [1,2,3,4]
+       ++X cyclicEntries t1
 
      cyclicEqual?: (%, %) -> Boolean
        ++ cyclicEqual?(t1, t2) tests of two cyclic trees have 
        ++ the same structure.
        ++
-       ++E t1:=tree [1,2,3,4]
-       ++E t2:=tree [1,2,3,4]
-       ++E cyclicEqual?(t1,t2)
+       ++X t1:=tree [1,2,3,4]
+       ++X t2:=tree [1,2,3,4]
+       ++X cyclicEqual?(t1,t2)
 
      cyclicParents: % -> List %
        ++ cyclicParents(t) returns a list of cycles that are parents of t.
        ++
-       ++E t1:=tree [1,2,3,4]
-       ++E cyclicParents t1
+       ++X t1:=tree [1,2,3,4]
+       ++X cyclicParents t1
 
  C== add
     cycleTreeMax ==> 5
@@ -407,15 +407,15 @@ BinaryTree(S: SetCategory): Exports == Implementation where
     ++ binaryTree(v) is an non-empty binary tree
     ++ with value v, and left and right empty.
     ++
-    ++E t1:=binaryTree([1,2,3])
+    ++X t1:=binaryTree([1,2,3])
     
    binaryTree: (%,S,%) -> %    
     ++ binaryTree(l,v,r) creates a binary tree with
     ++ value v with left subtree l and right subtree r.
     ++
-    ++E t1:=binaryTree([1,2,3])
-    ++E t2:=binaryTree([4,5,6])
-    ++E binaryTree(t1,[7,8,9],t2)
+    ++X t1:=binaryTree([1,2,3])
+    ++X t2:=binaryTree([4,5,6])
+    ++X binaryTree(t1,[7,8,9],t2)
     
   Implementation == add
      Rep := List Tree S
@@ -669,26 +669,26 @@ BinarySearchTree(S: OrderedSet): Exports == Implementation where
     binarySearchTree: List S -> %
      ++ binarySearchTree(l) \undocumented
      ++
-     ++E binarySearchTree [1,2,3,4]
+     ++X binarySearchTree [1,2,3,4]
 
     insert_!: (S,%) -> %
      ++ insert!(x,b) inserts element x as leaves into binary search tree b.
      ++
-     ++E t1:=binarySearchTree [1,2,3,4]
-     ++E insert!(5,t1)
+     ++X t1:=binarySearchTree [1,2,3,4]
+     ++X insert!(5,t1)
 
     insertRoot_!: (S,%) -> %
      ++ insertRoot!(x,b) inserts element x as a root of binary search tree b.
      ++
-     ++E t1:=binarySearchTree [1,2,3,4]
-     ++E insertRoot!(5,t1)
+     ++X t1:=binarySearchTree [1,2,3,4]
+     ++X insertRoot!(5,t1)
 
     split:      (S,%) -> Record(less: %, greater: %)
      ++ split(x,b) splits binary tree b into two trees, one with elements 
      ++ greater than x, the other with elements less than x.
      ++
-     ++E t1:=binarySearchTree [1,2,3,4]
-     ++E split(3,t1)
+     ++X t1:=binarySearchTree [1,2,3,4]
+     ++X split(3,t1)
 
   Implementation == BinaryTree(S) add
     Rep := BinaryTree(S)
@@ -730,14 +730,14 @@ BinaryTournament(S: OrderedSet): Exports == Implementation where
       ++ binaryTournament(ls) creates a binary tournament with the
       ++ elements of ls as values at the nodes.
       ++
-      ++E binaryTournament [1,2,3,4]
+      ++X binaryTournament [1,2,3,4]
 
     insert_!: (S,%) -> %
       ++ insert!(x,b) inserts element x as leaves into binary tournament b.
       ++
-      ++E t1:=binaryTournament [1,2,3,4]
-      ++E insert!(5,t1)
-      ++E t1
+      ++X t1:=binaryTournament [1,2,3,4]
+      ++X insert!(5,t1)
+      ++X t1
 
   Implementation == BinaryTree(S) add
     Rep := BinaryTree(S)
@@ -970,14 +970,14 @@ BalancedBinaryTree(S: SetCategory): Exports == Implementation where
       ++ balancedBinaryTree(n, s) creates a balanced binary tree with
       ++ n nodes each with value s.
       ++
-      ++E balancedBinaryTree(4, 0)
+      ++X balancedBinaryTree(4, 0)
 
     setleaves_!: (%, List S) -> %
       ++ setleaves!(t, ls) sets the leaves of t in left-to-right order
       ++ to the elements of ls.
       ++
-      ++E t1:=balancedBinaryTree(4, 0)
-      ++E setleaves!(t1,[1,2,3,4])
+      ++X t1:=balancedBinaryTree(4, 0)
+      ++X setleaves!(t1,[1,2,3,4])
 
     mapUp_!: (%, (S,S) -> S) -> S
       ++ mapUp!(t,f) traverses balanced binary tree t in an "endorder"
@@ -986,12 +986,12 @@ BalancedBinaryTree(S: SetCategory): Exports == Implementation where
       ++ f(l,r) where l and r are the values at the immediate
       ++ left and right nodes.
       ++
-      ++E T1:=BalancedBinaryTree Integer
-      ++E t2:=balancedBinaryTree(4, 0)$T1
-      ++E setleaves!(t2,[1,2,3,4]::List(Integer))
-      ++E adder(a:Integer,b:Integer):Integer == a+b
-      ++E mapUp!(t2,adder)
-      ++E t2
+      ++X T1:=BalancedBinaryTree Integer
+      ++X t2:=balancedBinaryTree(4, 0)$T1
+      ++X setleaves!(t2,[1,2,3,4]::List(Integer))
+      ++X adder(a:Integer,b:Integer):Integer == a+b
+      ++X mapUp!(t2,adder)
+      ++X t2
 
     mapUp_!: (%, %, (S,S,S,S) -> S) -> %
       ++ mapUp!(t,t1,f) traverses balanced binary tree t in an "endorder"
@@ -1002,12 +1002,12 @@ BalancedBinaryTree(S: SetCategory): Exports == Implementation where
       ++ corresponding nodes of a balanced binary tree t1, of identical
       ++ shape at t.
       ++
-      ++E T1:=BalancedBinaryTree Integer
-      ++E t2:=balancedBinaryTree(4, 0)$T1
-      ++E setleaves!(t2,[1,2,3,4]::List(Integer))
-      ++E adder4(i:INT,j:INT,k:INT,l:INT):INT == i+j+k+l
-      ++E mapUp!(t2,t2,adder4)
-      ++E t2
+      ++X T1:=BalancedBinaryTree Integer
+      ++X t2:=balancedBinaryTree(4, 0)$T1
+      ++X setleaves!(t2,[1,2,3,4]::List(Integer))
+      ++X adder4(i:INT,j:INT,k:INT,l:INT):INT == i+j+k+l
+      ++X mapUp!(t2,t2,adder4)
+      ++X t2
 
     mapDown_!: (%,S,(S,S) -> S) -> %
       ++ mapDown!(t,p,f) returns t after traversing t in "preorder"
@@ -1017,12 +1017,12 @@ BalancedBinaryTree(S: SetCategory): Exports == Implementation where
       ++ mapDown!(r,q,f) are evaluated for the left and right subtrees
       ++ l and r of t.
       ++
-      ++E T1:=BalancedBinaryTree Integer
-      ++E t2:=balancedBinaryTree(4, 0)$T1
-      ++E setleaves!(t2,[1,2,3,4]::List(Integer))
-      ++E adder(i:Integer,j:Integer):Integer == i+j
-      ++E mapDown!(t2,4::INT,adder)
-      ++E t2
+      ++X T1:=BalancedBinaryTree Integer
+      ++X t2:=balancedBinaryTree(4, 0)$T1
+      ++X setleaves!(t2,[1,2,3,4]::List(Integer))
+      ++X adder(i:Integer,j:Integer):Integer == i+j
+      ++X mapDown!(t2,4::INT,adder)
+      ++X t2
 
     mapDown_!: (%,S, (S,S,S) -> List S) -> %
       ++ mapDown!(t,p,f) returns t after traversing t in "preorder"
@@ -1034,12 +1034,12 @@ BalancedBinaryTree(S: SetCategory): Exports == Implementation where
       ++ pl and pr. Then \spad{mapDown!(l,pl,f)} and \spad{mapDown!(l,pr,f)}
       ++ are evaluated.
       ++
-      ++E T1:=BalancedBinaryTree Integer
-      ++E t2:=balancedBinaryTree(4, 0)$T1
-      ++E setleaves!(t2,[1,2,3,4]::List(Integer))
-      ++E adder3(i:Integer,j:Integer,k:Integer):List Integer == [i+j,j+k]
-      ++E mapDown!(t2,4::INT,adder3)
-      ++E t2
+      ++X T1:=BalancedBinaryTree Integer
+      ++X t2:=balancedBinaryTree(4, 0)$T1
+      ++X setleaves!(t2,[1,2,3,4]::List(Integer))
+      ++X adder3(i:Integer,j:Integer,k:Integer):List Integer == [i+j,j+k]
+      ++X mapDown!(t2,4::INT,adder3)
+      ++X t2
 
   Implementation == BinaryTree(S) add
     Rep := BinaryTree(S)
@@ -1112,20 +1112,20 @@ PendantTree(S: SetCategory): T == C where
    ptree : S->%
     ++ ptree(s) is a leaf? pendant tree
     ++
-    ++E t1:=ptree([1,2,3])
+    ++X t1:=ptree([1,2,3])
        
    ptree:(%, %)->%
     ++ ptree(x,y) \undocumented
     ++
-    ++E t1:=ptree([1,2,3])
-    ++E ptree(t1,ptree([1,2,3]))
+    ++X t1:=ptree([1,2,3])
+    ++X ptree(t1,ptree([1,2,3]))
 
    coerce:%->Tree S
     ++ coerce(x) \undocumented
     ++
-    ++E t1:=ptree([1,2,3])
-    ++E t2:=ptree(t1,ptree([1,2,3]))
-    ++E t2::Tree List PositiveInteger
+    ++X t1:=ptree([1,2,3])
+    ++X t2:=ptree(t1,ptree([1,2,3]))
+    ++X t2::Tree List PositiveInteger
 
  C == add
      Rep := Tree S
diff --git a/src/interp/format.boot.pamphlet b/src/interp/format.boot.pamphlet
index 7dca247..de87ba6 100644
--- a/src/interp/format.boot.pamphlet
+++ b/src/interp/format.boot.pamphlet
@@ -253,7 +253,7 @@ reportOpSymbol op1 ==
 \subsection{sayExample}
 This function expects 2 arguments, the documentation string and
 the name of the operation. It searches the documentation string for
-\verb|++E| lines. These lines are examples lines for functions. 
+\verb|++X| lines. These lines are examples lines for functions. 
 They look like ordinary \verb|++| comments and fit into the ordinary
 comment blocks. So, for example, in the plot.spad.pamphlet file we
 find the following function signature:
@@ -262,34 +262,34 @@ find the following function signature:
       ++ plot(f,a..b) plots the function \spad{f(x)} 
       ++ on the interval \spad{[a,b]}.
       ++ 
-      ++E fp:=(t:DFLOAT):DFLOAT +-> sin(t)
-      ++E plot(fp,-1.0..1.0)$PLOT
+      ++X fp:=(t:DFLOAT):DFLOAT +-> sin(t)
+      ++X plot(fp,-1.0..1.0)$PLOT
 \end{verbatim}
-This function splits out and prints the lines that begin with \verb|++E|.
+This function splits out and prints the lines that begin with \verb|++X|.
 
 A minor complication of printing the examples is that the lines have
 been processed into internal compiler format. Thus the lines that read:
 \begin{verbatim}
-      ++E fp:=(t:DFLOAT):DFLOAT +-> sin(t)
-      ++E plot(fp,-1.0..1.0)$PLOT
+      ++X fp:=(t:DFLOAT):DFLOAT +-> sin(t)
+      ++X plot(fp,-1.0..1.0)$PLOT
 \end{verbatim}
 are actually stored as one long line containing the example lines
 \begin{verbatim}
 "\\indented{1}{plot(\\spad{f},{}a..\\spad{b}) plots the function
  \\spad{f(x)}} \\indented{1}{on the interval \\spad{[a,{}b]}.}
  \\blankline
- \\spad{E} fp:=(t:DFLOAT):DFLOAT +-> sin(\\spad{t})
- \\spad{E} plot(\\spad{fp},{}\\spad{-1}.0..1.0)\\$PLOT"
+ \\spad{X} fp:=(t:DFLOAT):DFLOAT +-> sin(\\spad{t})
+ \\spad{X} plot(\\spad{fp},{}\\spad{-1}.0..1.0)\\$PLOT"
 \end{verbatim}
 
-This function finds examples and strips off the prefix \verb|\\spad{E}| 
+This function finds examples and strips off the prefix \verb|\\spad{X}| 
 from the stored form and calls cleanupLine to get rid of the other noise.
 <<*>>=
 sayExample(docstring,op) ==
- point := SEARCH('"{E}",docstring)
+ point := SEARCH('"{X}",docstring)
  point => 
   line := SUBSEQ(docstring,point+3)
-  while (mark:=SEARCH('"{E}",line)) repeat
+  while (mark:=SEARCH('"{X}",line)) repeat
    mark > 0 =>
     PRINC cleanupLine (SUBSEQ(line,0,mark-6))
     sayNewLine()