1) Generic instance for internal types - test case:

    import System.Collections.Generic

    class Person:
        [property(Name)] _name = ""

    l = List of Person()
    l.Add(Person(Name: "Eric Idle"))
    assert "Eric Idle" == l[0].Name

Currently this will trigger an internal compiler error in
ExternalGenericTypeDefinition.MakeGenericType. The solution is to
implement a new IType class, GenericTypeInstance, which can behave
like an instantiated generic type (this will also trigger need for
GenericMethodInstance, etc...).

2) Type inference for IEnumerable of T:

     import System.Collections.Generic
     ints = List of int()
     ints.Add(21)
     for i in ints: # compiler should infer i as int
           print i*2

3) Generic type references:

     import System.Collections.Generic
     def foo() as IEnumerable of int:
        return (1, 2, 3, 4)

4) Generic generators:

     def ff() as IEnumerable of int:
        yield 1
        yield 1
        yield 2

5) Generic callable instantiation:

     function as ParameterizedThreadStart of int
     function = { i as int | print i*2 }
     Thread(function).Start(21)

     and then more simply:

     Thread({ i as int | print i*2}).Start(21)

6) Implementing generic interfaces

7) overriding generic members

8) defining new generic types

I'm focusing more on language extensibility lately, trying to finally
get a somehow unified and easy to use macro system out of my brain.

--
bamboo