(****
 *
 * This spec shows examples of the two RSL operators that test and select
 * instance values from a class value.  The operators are:
 *
 *	OPERATOR	MEANING
 *	==================================================================
 *	  x?<T		Return true if x is a variable of type P and T is an
 *			extends P.  This expression is in error if T is not
 *			an extends P.
 *			
 *	  x.<T		Select the value of type T from a variable of type P,
 *			where T is an extends P.  The value of this
 *			expression is nil if the current value of x is not of
 *			type T (i.e., it is of some other instance type of P).
 *			This expression is in error if T is not an extends
 *			P.
 *
 * The reader should note that these two operators are natural extensions of
 * the '?' and '.' operator for unions.  I.e., the '?' operator for a union
 * tests for one of its alternative types; similarly, the '?<' operator for a
 * class tests for one of its alternative subclass types.  The '.' operator for
 * a union selects one of its alternative types; similarly, the '.<' operator
 * for a class selects one of its subclass alternatives.
 *
 * The example expressions below show correct and incorrect uses of these class
 * operators.  Run this file through the RSL checker to see the exact error
 * messages that are output for the erroneous expressions.
 *)

obj GenericObj = gs:GenericStuff;

obj SpecificObj1 < GenericObj = ss1:SpecificStuff1;
obj SpecificObj2 < GenericObj = ss2:SpecificStuff2;
obj SpecificObj1a < SpecificObj1 = ss1a:SpecificStuff1;

obj GenericStuff = integer;
obj SpecificStuff1 = integer;
obj SpecificStuff2 = integer;
obj SpecificStuff1a = integer;


op FiddleAroundSome(go:GenericObj, so1:SpecificObj1, so2:SpecificObj2,
	so1a:SpecificObj1a) -> (boolean) =
(
    (*
     * The next three expressions show that the variable go of type GenericObj
     * is not directly compatible with variables of its subclass types.  In
     * order to obtain a value of a subclass type from go, the ?< and .<
     * operators can be used, as shown below.
     *)
    (go = so1)	    (* ERROR: GenericObj is not type equiv to SpecificObj1 *)
	or
    (go = so2)	    (* ERROR: GenericObj is not type equiv to SpecificObj2 *)
	or
    (so1 = so1a)    (* ERROR: SpecificObj is not type equiv to SpecificObj1a *)
	or

    (*
     * The next four expressions show how to use the ?< and .< operators to
     * test and select subclasss values from variable go.
     *)
    (go?<SpecificObj1 = true)	(* OK: go?<SpecificObj1 returns true if the
				       current value of go is of type
				       SpecificObj1. *)
	or
    (go.<SpecificObj1 = so1)	(* OK: go<.SpecificObj1 selects the value of
				       type SpecificObj1 from go. *)
	or
    (so1.<SpecificObj1a = so1a)	(* OK: so1.<SpecificObj1a extracts the value of
				       SpecificObj1a from so1. *)
	or
    (go.<SpecificObj1.<SpecificObj1a = so1a);	(* OK *)
);