<http://docs.python.org/reference/expressions.html>`_ (along with the
+``py.js`` currently implements the following builtins:
+ Restricted to creating new types, can't be used to get an object's
+ Returned from rich comparison methods when the comparison is not
+ implemented for this combination of operands. In ``py.js``, this
+ is also the default implementation for all rich comparison methods.
+ Does not inherit from ``int``, since ``int`` is not currently
+ Constructor/coercer is not implemented, only handles literals
+ Same as tuple (``list`` is currently an alias for ``tuple``)
+ Implements just about nothing
+Note that most methods are probably missing from all of these.
+``py.js`` currently implements the following protocols (or
+sub-protocols) of the `Python 2.7 data model
+ Roughly complete implementation but for two limits: ``__eq__`` and
+ ``__ne__`` can't return ``NotImplemented`` (well they can but it's
+ not going to work right), and the behavior is undefined if a
+ rich-comparison operation does not return a ``py.bool``.
+ Also, a ``NotImplemented`` result does not try the reverse
+ operation, not sure if it's supposed to. It directly falls back to
+ Implementing ``__nonzero__`` should work.
+Customizing attribute access
+ Protocols for getting and setting attributes (including new-style
+ extension) fully implemented but for ``__delattr__`` (since
+ ``del`` is a statement)
+ As with attributes, ``__delete__`` is not implemented.
+Collections Abstract Base Classes
+ Container is the only implemented ABC protocol (ABCs themselves
+ are not currently implemented) (well technically Callable and
+ Hashable are kind-of implemented as well)
+ Basically not implemented, the only part of it which is
+ implemented is the unary ``-`` (because it's used to create
+ negative floats, they're parsed as a negated positive number)
+``py.js`` also provides (and exposes) a few utilities for "userland"
+ that it can be called from native expressions.
+ Does not ensure the return types are type-compatible with
+ When accessing instance methods, ``py.js`` automatically wraps
+ these in a variant of ``py.def`` automatically, to behave as
+ Python's (bound) methods.