# Exactly the same rules as arith.gra, but now every expression has a type:
# integer or real.  In general, only arguments of the same type may be combined.
# However, 0 is of both types, and sqrt applies to both types (and returns real).

# ----------------------------------------------------------------------

# The most basic form of rule writing.

1 EXPR[sem=plus(X,Y) type=T]	EXPR[sem=X type=T] + TERM[sem=Y type=T]
1 EXPR[sem=minus(X,Y) type=T]	EXPR[sem=X type=T] - TERM[sem=Y type=T]
1 EXPR[sem=X type=T]	TERM[sem=X type=T]

# Again, the TERM rules are strictly analogous to the EXPR rules,
# so we will use them to demonstrate some other notations for saying
# that the two terms and the factor all have the same type.
# 
# The multiplication rule has been split into two rules, one for
# int and one for real.  If one fails then the other will be used,
# so 3 * 3 and pi * pi both work, not to mention 0 * 3 and 0 * pi.
# We use itimes for integer multiplication and rtimes for real multiplication.

1 TERM[sem=itimes(1,3) type=1]	TERM[type=int] * FACTOR[type=int]
1 TERM[sem=rtimes(1,3) type=1]	TERM[type=real] * FACTOR[type=real]

# Here, the first child TERM is constrained to have the same type as
# the third child ("type=3"), which in turn is constrained to have the
# same type as the parent ("type=0").  buildattrs does the right thing
# and ensures that the parent receives the attribute.

1 TERM[sem=div(1,3)]	TERM[type=3] / FACTOR[type=0]  

# The remaining rules make much use of the =1 notation so that the
# parent can easily inherit a child's sem and type attributes without
# spelling them out.  

1 TERM[=1]		FACTOR

1 FACTOR[=1]		Num
1 FACTOR[=2]		{ EXPR }
1 FACTOR[sem=1(3) type=real]	sqrt { EXPR }   # EXPR can have either type

1 ROOT[=1] 		EXPR

1 Num[=1]	        0    # just for fun, say 0 allows any type

1 Num[=1 type=int]	1
1 Num[=1 type=int]	2
1 Num[=1 type=int]	3
1 Num[=1 type=int]	4
1 Num[=1 type=int]	5
1 Num[=1 type=int]	6
1 Num[=1 type=int]	7
1 Num[=1 type=int]	8
1 Num[=1 type=int]	9

1 Num[=1 type=real]	pi
1 Num[=1 type=real]	e
1 Num[=1 type=real]	0.5