Refresh the type of variables in the environement to avoid clash with variables of the interface of the function being typed.

Only use the old typing of applications for ground types (not types with only monomorphic variables)

Remove commented code in clean_type. Restore cleaning of variables that are in covariant position in the result type, to avoid having strange types such as: [] -> [ ('b) * ]

Given a type for which each kind is i DNF :

ints: \/ /\a /\v /\~b /\~w
chars: \/ /\a /\v /\~b /\~w
...

where a, b are atoms and v w toplevel variables, index the type by
pairs of variables, for each kind, which gives a matrix of 8 lines.
                    ...   (v, w) ...   (x,y) ...
ints:                      t1           t1
chars:                     ...         ...
atoms:
times:
xml:
arrow:
record:
abstract:                  t8           t8

let T = t1 | ... | t8,
we can write ((v & w) | (x & y)) & T
we now try to factor according to variables (intersection of v x and w y)
to have a type of the form: ('a | ... | 'd) & 'e ... & (Any \ 'f) & T

cases like this:

	type t = ['b '@' 'a]

We have a syntax error because CDuce thinks 'b ' as a string, to fix that,
implicitly write:

	type t = [('b) '@' 'a]

variables in brackets. However, we can't write ';;' in strings in brackets in
toplevel now:

	# type t = ['a];;
	# type t = ['a'];;
	# type t = ['a 'a'];;
	# type t = [';;'];;
	Characters 10-11:
	Illegal character

We still have to print a better error message.

* 'master' of https://git.cduce.org/cduce:
  Preliminary work-around to only substitute by any/empty variables that were introduced by the tallying.
  [TESTS] Progress in stdlib/list

Preliminary work-around to only substitute by any/empty variables that were introduced by the tallying.

precise = false returns the constraint itself as output type (which is not sound when it is a variable).

for each component (int, atoms, pairs...) we optimize the case where the component is like

  T1&'a | T2 | T3&'a

we split it into
- T2
- T1 &'a | T3 &'a
we retrieve { 'a } as the set of top level vars in the second type
we compute T2 &'a | T1 &'a | T3 &'a
then remove 'a from that type and return finally :

T2 | ('a & (T1 | T2 | T3))

We special case if (T1 | T2 | T3) is top, then we just display
T2 | 'a

of sequence|non_variable|(toplevelvar ^ rest)
with special cases when non_variable or sequence are empty and toplevelvar or rest are any
(or any combination of thoses).

Add the examples of the part2 paper in a test file.

not propely propagate in case the left component was a 1 element intersection or union
containing an arrow)
Note: we should not have been generating such types in the first place.

Fix typing of application. Apply the polymorphic code when either the function or its argument have variables.

This reverts commit 045a8519.

- delta is now kept into consideration when memoizing

Tallying and printing still broken.

- delta is not yet used to do anything meaningful
- remove optional argument ?fresh from Var.mk (legacy not used)
- print -> pp,printf refactoring

now as such:
	- ['a] is the regexp matching the type variable "a";
	- ['a'] is the regexp matching the string "a";
	- ['a' 'a] is the regexp matching the string "a" followed by the type
	variable "a";
	- ['a''a] is a syntax error (a string in single quotes in a regexp MUST
	be followed by a character that cannot be the beginning of a name for a
	type variable, a blank character will do).

Bug: At this point, when using CDuce at toplevel, one will have to press enter
twice when typing a regexp with type variables.