Hello, This seems like a great project. I would *love* to see a more widespread type language for Python. I am commenting less on the skeleton collection because I think just mimicking DefinitelyTyped and Homebrew is such a good way to do it that I support it completely. I will definitely contribute skeletons for my dependencies in order to get better checking for my projects. For the type language... I am *less* concerned with: - *The exact concrete syntax for types.* I think Foo -> Bar and [Foo] and{Foo:Bar}are all nicer than Function[Foo,Bar] and List[Foo] and dict[Foo,Bar], but as long as the underlying type system has these concepts and there is *some* syntax for them (which there is not in typeannotations, mypy, or any contractl ibrary that I know of) then everything is fine. And we can always support shorthands in addition to the direct __repr__ style of writing these types. - *How the types get into Python code.* This is probably best done a few different way. The way that typeannotations and mypy do it with Python 3 annotations is lovely, but we cannot wait for Python 3 support everywhere. Docstrings in a various of ways are fine. This decision should be independent from the type language itself. - *How the types are checked*. Static checking is super, and dynamic checking is really helpful too, but as the docstring formats show it is really amazing to even just have the types for a human to read, and document your intent in a rigorous way. Wild monkey patching and reflection will probably always make it hard to be actually type safe and that would be unpythonic anyhow. I am *most* concerned with the *abstract* type language. Here are notes on the current proposal (and some context): - *The type language must have function types.* It is really disappointing when the only when I can describe a function's type is interleaved with its definition. It is very important to be able to say "method some_method has type (int, datetime, {int:str}, *str) -> str. Without this, I don't even have the words to describe the method. - *The type language should really have "static duck types"*. These were mentioned briefly by Vladimir. The technical term is row types, and they are only currently in python-rightarrow with the concrete syntax like object(self_type, field: type, field: type, ...). Without this, I don't have the words to describe an object. It is not really Pythonic to describe it in terms of its implementation when all that matters is that it has certain methods (of certain types). - *The type language should allow types for *args and **kwargs*. I do not see this in the current proposal. The current python-rightarrow contains one idea but I think it can be simplified to e.g. (Foo, *Bar, **Bizzle) -> Baz (since kwargs has to have str keys -- I think? -- you only give the type of its values.) - *Generics are just variables and should allow self-documenting names. *Just a little thing; Reserving T-Z for generics makes it so you cannot give them useful names. To be very clear: I believe these things about the whole project: - *I think the abstract type language can be describe without being too rigid about the concrete syntax.* The actual ways in which Python data structure are put together is not going to change any time soon, so if we get the abstract part right, there can be innovation in the concrete syntax, shorthands, etc. In fact, tuples, lists, dicts, and functions are all "real" things that exist pretty much independently of Python. I feel sort of the same way about row types, etc. So we may as well use the universal abstract syntax for them and give it a Pythonic concrete syntax. - *I think all of that can be defined without having a type checker (or even a type system) to handle all of them perfectly. *Any type that is too hard for a type checker can be treated as "unknown". Questions: - The type language proposal should go in its own repo perhaps? - How will license be handled for the major central repo of skeletons? I would prefer a global BSD/Apache/MIT/whatever style license and make that clear in CONTRIBUTING. Disclaimer: I am the author of python-rightarrow which is really an unimportant and barely-started side project to develop a simple type language for Python. I have a lot of experience with programming language and type checking / type inference / static-dynamic hybrid type implementation. I hope the result of this discussion makes my project obsolete. Cheers, - Kenn