--* From postmaster%watson.vnet.ibm.com@yktvmv.watson.ibm.com  Sat Jul  9 00:23:44 1994
--* Received: from yktvmv-ob.watson.ibm.com by asharp.watson.ibm.com (AIX 3.2/UCB 5.64/930311)
--*           id AA28014; Sat, 9 Jul 1994 00:23:44 -0400
--* Received: from watson.vnet.ibm.com by yktvmv.watson.ibm.com (IBM VM SMTP V2R3)
--*    with BSMTP id 5013; Sat, 09 Jul 94 00:23:47 EDT
--* Received: from YKTVMV by watson.vnet.ibm.com with "VAGENT.V1.0"
--*           id <A.JENKS.NOTE.VAGENT2.4191.Jul.09.00:23:46.-0400>
--*           for asbugs@watson; Sat, 09 Jul 94 00:23:47 -0400
--* Received: from YKTVMV by watson.vnet.ibm.com with "VAGENT.V1.0"
--*           id 4187; Sat, 9 Jul 1994 00:23:46 EDT
--* Received: from leonardo.watson.ibm.com by yktvmv.watson.ibm.com
--*    (IBM VM SMTP V2R3) with TCP; Sat, 09 Jul 94 00:23:45 EDT
--* Received: by leonardo.watson.ibm.com (AIX 3.2/UCB 5.64/920123)
--*           id AA25979; Sat, 9 Jul 1994 00:19:00 -0400
--* Date: Sat, 9 Jul 1994 00:19:00 -0400
--* From: jenks@leonardo.watson.ibm.com
--* X-External-Networks: yes
--* Message-Id: <9407090419.AA25979@leonardo.watson.ibm.com>
--* To: asbugs@watson.ibm.com
--* Subject: [1] Ending a block with an if ==> segmentation error with no message [/u/jenks/dimacs94/ex.pm/rulebug.as][?]

--@ Fixed  by:  SSD   Wed Aug 10 00:45:25 EDT 1994 
--@ Tested by:  none 
--@ Summary:    Fixed the handling of exits from a sequence. 


#include "rewriteRule.as"

--X ==> Xtree S;
R ==> RewriteRule S;

Ruleset(S: BasicType): BasicType with {
--	lookup: (X, %) -> Partial R;
--	substitute: (%, X) -> X;
--        insert!:   (X, X, %) -> %;
--        empty: %;
--        rest: % -> %;
--      ruleset: List List X -> %
} == add {
	Rep ==> List R;
	import from Rep;
        import from R;

--      rest(u: %): % == per(rest(rep u)$Rep);
--      rest(u: %): % == false;

        sample: % == per [];

--      (u: %) = (v: %): Boolean == {(rep u) =$Rep (rep v)};
        (u: %) = (v: %): Boolean == false;

--      empty: % == per [];

--        ruleset(u: List List X): % == empty;
--        ruleset(u: List List X): % == {
--          acc: % := empty;
--          for x in u repeat
--            acc := insert!(first x, first rest x,acc);
--          acc
--        }
--
--        lookup(x: X, u: %): Partial R == rewriteRule(x,x) :: Partial R;
--        lookup(x: X, u: %): Partial R == {
--          import from X;
--          empty? rep u => failed;
--          y: R := first rep u;
--          x =$X lhs y => y :: Partial(R);
--          lookup(x, per rest rep u)
--        }

--          substitute(al: %, t: X) : X == t;
--        substitute(al: %, t: X): X == {
--          import from Partial R;
--          import from List X;
--          not (failed? (u := lookup(t, al))) => rhs (u :: R);
--          leaf? t => t;
--          tree [substitute(al, x) for x in subtrees t]
--        }

--      insert!(a: X, b: X, l: %): % == ruleset list( [a,b]);
--	insert!(a: X, b: X, l: %): % == {
--          u := rep l;
--          empty? u => per [rewriteRule(a,b)];
--          repeat {
--            a = lhs first u => {
--              setRhs!(first u, b);
--              return l
--            }
--            empty? rest u => break;
--            u := rest u
--          }
--          setRest!(u, [rewriteRule(a, b)]);
--          l
--        }

        (outp: TextWriter) << (t: %): TextWriter == {
		import from String;
--                outp << "[";
--              data := rep t;
                if false then {
--                  writeItem(outp, first data);
--                  for x in rest data repeat {
--                    outp << ", ";
--                    writeItem(outp, x)
--                  }
                outp << "]"
                }
	}

--      local writeItem(outp: TextWriter, p: R): TextWriter == {
--                import from X;
--                outp << lhs p << " -> " << rhs p;
--        }
}