GitLab

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.

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

Fix Typer.pp_env printer for types
Minor code refactring

Conflicts:
	Makefile.distrib
	depend

Change $$ in >> in types.ml for the substitution operator

Do not generate equations for monomorphic variables, during the generation of type equation from constraints.

- New fresh variables now share the same str, but different freshness index
- Remove the function is_internal from var module

Fix a pretty printing error for ground types (the negative part was not shown due to "worth_complement" being called twice).

Fix a pretty printing error for ground types (the negative part was not shown due to "worth_complement" being called twice).

Rework the type variable infrastructure. Remove it from the type structure and have the auxiliary function cache the results as needed.

when a constraint 'a < t or t < 'a with 'a being monomorphic occurs during constraint generation, we check whether
it holds for all 'a, that is we use plain subtyping.
(It generalizes the fact that 'a < Any or Empty < 'a hold for monomorphic variables, but also accounts for constraints such as 'a < 'a | t and so on).

- Change the precedence of the XML constructor to be stronger than the set-theoretic operations (compatibility with previous CDuce)
- Pretty-printing of regular expressions. When the input type contains a sequence type, print the sequence as a regular expression. Do not print empty sequences unless the rest of the atom components is finite:
     `a |`b | `nil
will be printed as
     [] | `a | `b
but
     Atom \ 'a
will be printed as
     Atom \'a
and not
     Atom \ ('a | `nil) | []
- Remove Arrow from positive arrow part (unless it is the only component)
- Fix a bug where records would be printed instead of attributes

- Simplify the pretty-printing descriptor type
- Fix a bug where some unions were shown as intersections
- Correctly display parentheses where needed (issue: #17)
- Prevent sharing for "small" subtrees (AST less than 6 nodes), so:
  (Int -> Int) -> Int -> Int
  is not shown as:
  X1 -> X1 where X1 = Int -> Int
  (but bigger types are).

distribute it (redudantly) under all variables to simplify their pretty-printing.

Hence, instead of having e.g. :

('a \ (Int)) | Char | Int | Atom)

we have
('a | Char | Int | Atom)

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

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

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.

This reverts commit 045a8519.