=============================
Re: notes from Jython meeting
=============================

* In PEPs Abstract rarely went straight to the meat of the discussion.
  I'll try to make the first few examples in the **Type Definition
  Syntax** stronger.  There's no reason I'm using ``.format()`` at this
  point.

* Yes, the lack of Callable signature definition is an ommision, it's
  going to be hard to use it with the subscription syntax Callable[].
  We can't use the call syntax Callable() if we wish to operate directly
  on ABCs, which I believe is what the users will expect.  We can't
  since the syntax wouldn't work on concrete subclasses of ABCs.
  I added this as an open issue in README.

* The remark about removing ``types`` from being mentioned actually
  makes me think we could solve many issues before they arise by
  introducing a short section **The place of the ``typing`` module in
  the standard library** which would explain how the authors intend for
  it to be used and what is its role compared to builtin types,
  ``types``,  ``collections``, and ``collections.abc``.  The worries
  that Guido has about the ``types`` module being ill-suited for type
  hinted are spot on, we should mention that in the document.

* I am thrilled by ``Set[Employee]`` returning a new class object that
  is a Set-of-Employees.  This leaves the door open for runtime
  inspection.  However, that immediately raises the questions:

  * ``Set is not Set[Employee] == True``, right?

  * ``Set is Set[Any] == True``, right?

  * ``Set[Employee] is Set[Union[Employee]] == True``, right?

  * ``issubclass(Set[Employee], Set)``, right?  We must accept a set of
    employees in every place that accepts "any set".  Taking the latter
    check into account, we'd have ``issubclass(Set[Employee],
    Set[Any])``. The covariance/contravariance discussion needs to
    happen at some point.

* While I don't see the point of ``AnyStr`` specifically (reeks too much
  of ``basestring``), I see that it's a useful example for ``Var``.
  You're right it's not equivalent to ``Union[bytes, str]``, it must be
  obviously parametric to keep the other occurences in scope consistent.
  With ``Var`` the syntax I was thinking about a following expression::

    AnyStr = Var('AnyStr', base=Union[str, bytes])

  Now that I saw this, I asked myself if that should be equivalent to
  ``typevar('AnyStr', values=(str, bytes))`` and the answer is "No".
  Union is not parametrized, hence not kept in sync between occurences.
  My mistake makes me wonder if we should make the parametrized types
  syntax more explicit for the type definition reader (in Java world
  seeing <? extends A> is pretty clear). I will ponder about this some
  more.

* Interoperability of ``typing.List`` with ``java.util.ArrayList``
  sounds good in principle.

* Realistically I think retroactive conformance in Python is going to be
  achieved by means of ABC.register() and/or Protocol.register().
  I have my hopes in using protocols as a more static analysis-friendly
  version of __subclasshook__

Unadressed matters
------------------

Lack of time currently to write about the following, will adress as soon
as I get to it again.

* how does filter() construct an instance of Y, write an implementation,
  extend Callable to say Callable[X]

* typevar values vs. Var base=

* should we encourage using abstract types: in principle yes, in
  practice there's issues (long type names, strings and bytes being
  iterables and sequences)

* consequences of covariance in generics as compared to invariance

* support for structural types
