Improve the debugging of the unify step of the tallying. Fix a bug where substitutions were applied in the wrong order, yielding partially empty types.

This reverts commit a8ba6ab6.

This commit introduces a regression where suprious type variables are introduced in the final type.

Seal the representation of SortedList.Make(X).t (by making the type private). Expose Var.Set as a SortedList.S

Perform a more aggressive memoization of substituted types and register the name if the original type was named.
Make the pretty-printer re-entrant.

remain regular. Within their recursive definitions, parametric types
must always be instantiated with their original parameters and all
types of mutually recursive definitions must have the same parameters.

We use Tarjan's strongly connected components algorithm to group type definitions accordingly.

correctly handle insantiated types in regular expressions.

suggest to put a space before the second quote.

Move the auxiliary 'warning' function from the typechecker to the
Cduce_loc module.

Re-indent some comments in ulexer.ml

requiring an abscence of whitespace between ``t'' and ``(''.  Outside
of regular expression contexts, ``t (t1, …, tn)'' is parsed with a
higher precedence than & and \, to allow one to write
``t (Int) & Bool'' without extra parentheses (i.e.
``(t (Int)) & Bool'').  Inside a regular expression, type
instantiation and sequencing become ambiguous, and there is no way to
distinguish syntactically: ``[ Int (Int, Int) ]'' from
``[ t (Int, Int) ]''. The former should resolve to a sequence while
the latter only makes sense as an instantiation (if ``t'' is a
parametric type). Both are treated as element sequencing and
disambiguated during identifier resolution (more precisely during the
"derecurse" phase, before typechecking).

Note that due to the lower precedence of sequencing w.r.t to other
regular expression constructs, a type ``[ t (Int)* ]'' will be parsed
correctly, but yield an error message saying that t is not fully
intantiated. One has to write ``[ (t (Int))* ]'' which is similar to
function applications for expressions.

Finally, we also re-order sequencing after typing to always group a
potential type instantiation with its argument, i.e. we transform
sequences such as
``[ t1 t2 t3 ... tn ]'' (which are parsed as
``[ (((t1 t2) t3) ... tn) ]'' because sequence concatenation is
left-associative) into ``[ ... (ti tj) ... ]'' if ``ti'' is an
identifier and ``tj'' is of the form ``(s1,...,sk)''. This is sound
because concatenation of regular expression is associative (and the
original sequence would fail, anyway).

when a type such as

type t('a) = (Int,'a)

is introduced, the variables occuring in the definitions are replaced by fresh occurences.
The variables in the left-hand-side were note renamed accordingly, yielding a type definition:

type t('a_0) = (Int, 'a_1)

when performing type substitutions, none of the occurences of 'a_1 were replaced.

Simplify (and fix) the code adding variables of a function interface to delta during the typing of its body.

Delay the check that detects types variables occurring in patterns until type-checking time (this allows us to have access to delta and thus know the monomorphic variables, which are allowed)

Revert "Partially revert commit 46a5262a (only file typing/typer.ml) to make balance type (in toplevel). This should be investigated more thoroughly."

This partial revert allows us to typecheck the wrong version of balance.

This reverts commit b98abca3.

Partially revert commit 46a5262a (only file typing/typer.ml) to make balance type (in toplevel). This should be investigated more thoroughly.

This reverts commit c9ad3e5c.

Conflicts:
	types/var.ml
	typing/typer.ml

Add a global variable table, so when we call "Var.mk id" twice, the
same variable is returned and when we call "Var.fresh v" we always
return a truly globally fresh variable.

now we can write types as
type t( 'a) = <a>'a

and patterns can contain type instantiations
let f = fun (t('a) -> [ t('a)* ]) x -> [ x ];;
let id = fun (t(Int) -> [ t(Int)* ]) x -> [ x ];;

Note: parametric types must be written as "IDENT(" without space.

- change syntax to avoid conflicts ( tried "((", "[<", "<[", "(" )
   type t {[ 'a,'b ]} = (Int,[ 'b* ]) ;;
   let app (f : 'a -> t {[Int,Int]} )(a : 'a) : t = f a;;

- type t 'a = ('a,'a)
- type t ('a,'b) = ('a,'b)

Fix Typer.pp_env printer for types
Minor code refactring

- Var identifiers are now of type U.t instead of string
- Remove TVar from ast. Polymorphic variables are just types