(****
 *
 * This	spec shows examples of two operators that test and extract 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		Extract 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 example expressions below show correct and incorrect uses of these
 * operators.  Run this file through the checker to see the exact error
 * messages that are ouput 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) =
(
(*  var x:SpecificObj1; *)

    (go = so1)	    (* ERROR: GenericObj is not type equiv to SpecificObj1 *)
	;
    (go = so2)	    (* ERROR: GenericObj is not type equiv to SpecificObj2 *)
	;
    (so1 = so1a)    (* ERROR: SpecificObj is not type equiv to SpecificObj1a *)
	;
    (go?<SpecificObj1 = true)	(* OK: go?<SpecificObj1 returns true if the
				       current value of go is of type
				       SpecificObj1. *)
	;
    (go.<SpecificObj1 = so1)	(* OK: go<.SpecificObj1 extracts the value of
				       type SpecificObj1 from go. *)
	;
    (so1.<SpecificObj1a = so1a)	(* OK: so1.<SpecificObj1a extracts the value of
				       SpecificObj1a from so1. *)
	;
    (go.<SpecificObj1.<SpecificObj1a)	(* ERROR: This is subtle.  The left
					          operand of the '<.' operator
					          must be a directly defined
					          variable, not an expression.
					          The details of why this is
					          the case are somewhat
					          involved -- just remember
					          this as a limitation of the
					          '<.' and '?.' operators. *)
	;
    let x = go.<SpecificObj1
	;
    (x.<SpecificObj1a)
	;
    false
	;
);