var s : Type; t : Type

class b < {x . x < s_v1}

%% assume s < t

class a < {x . x < t_v2}

class a < b

class a < {y . y < t_v2}

%% ok (but only for simple tokens)

class a < {y . y < s_v1}

class c, d < Type

class a < (c, d)

class e < a

%% ok

class h < e

%% ok

class h < (a, b)

%% ok

class e < {x . x < t_v2}

%% Classes ---------------------------------------------------------------

a < ({y . y < s_v1}, {x . x < t_v2}, b, c, d)

b < {x . x < s_v1}

c < Type

d < Type

e < ({x . x < t_v2}, a)

h < (a, b, e)

%% Type Constructors -----------------------------------------------------

Logical : Type := Unit ->? Unit

Pred : Type -> Type := \ a : Type . a_v-1 ->? Unit

Unit : Type := Unit

__*__ : Type+ -> Type+ -> Type

__-->__ : Type- -> Type+ -> Type

__-->?__ : Type- -> Type+ -> Type

__->__ : Type- -> Type+ -> Type

__->?__ : Type- -> Type+ -> Type

s : Type %(var_1)%

t : Type %(var_2)%

%% Assumptions -----------------------------------------------------------

__/\__ : Unit * Unit ->? Unit %(fun)%

__<=>__ : Unit * Unit ->? Unit %(fun)%

__=__ : forall a : Type . a_v-1 * a_v-1 ->? Unit %(fun)%

__=>__ : Unit * Unit ->? Unit %(fun)%

__=e=__ : forall a : Type . a_v-1 * a_v-1 ->? Unit %(fun)%

__\/__ : Unit * Unit ->? Unit %(fun)%

__if__ : Unit * Unit ->? Unit %(fun)%

__when__else__

: forall a : Type . a_v-1 * Unit * a_v-1 ->? a_v-1 %(fun)%

bottom : forall a : Type . a_v-1 %(fun)%

def__ : forall a : Type . a_v-1 ->? Unit %(fun)%

false : Unit %(fun)%

not__ : Unit ->? Unit %(fun)%

true : Unit %(fun)%

�__ : Unit ->? Unit %(fun)%

%% Diagnostics -----------------------------------------------------------

*** Hint 1.5, is type variable 's'

*** Hint 1.7, is type variable 't'

*** Warning 7.7, redeclared class 'a'

*** Warning 9.7, redeclared class 'a'

*** Warning 11.7, redeclared class 'a'

*** Warning 15.7, redeclared class 'a'

*** Warning 21.7, redeclared class 'h'

*** Warning 23.7, redeclared class 'e'