[Types-sig] Interfaces API

[Paul Prescod]

We'll need to agree on an API for interfaces. My API is very simple:

interface Interface:
    """The shared behavior of interface objects"""
    def __check__(self, obj)
  
Michel's is a little more "feature rich":

        interface InterfaceInterface(InterfaceBaseInterface):
            """   
            This is the interface to interface objects that 
            are described in this document.   
            """

            def getBases():
                """  
                Returns a sequence of base interfaces 
                this interface extends.
                """

            def extends(other): # convenience function?
                """   
                Does this interface extend the 'other' interface?
                """

            def isImplementedBy(object): # convenience function?
                """
                Does the given object implement the interface?
                """

		# convenience function?
            def isImplementedByInstancesOf(klass):
                """ 
                Do instances of the given class implement
                this interface?
                """
                
		# do you differentiate between required 
		# and optional names? I ask because it seems like it
		# would make sense to have docstrings and other 
		# metadata for optional methods etc.
            def names():
                """
                Return the attribute names defined by the interface
                """

            def namesAndDescriptions():
                """
                Return the attribute names and description 
                objects defined by the interface
                """

		# convenience function?
            def getDescriptionFor(name, default=None):
                """
                Return the attribute description 
                object for the given name
                """

		# I think deferred classes were taken out of the PEP
            def deferred():
                """
                Return a deferred class corresponding to 
                the interface.
                """

I'm surprised that you don't have the equivalent of my __check__. Given
an object don't we want a way to ensure that it really does have the
right names, methods with the right parameters and so forth? In my mind,
__check__ is the major feature required for runtime checks. The other
stuff is of lesser interest ot me.

Also, I wonder if an API could get into the core language with
CamelCaseMethodNames. Guido Isn't A CamelCaseGuyAfterAll. I really
prefer camel case myself but what's the point in fighting the BDFL on
religious issues? (I'll point out, however that camel case names would
have a consistent syntax for hasAttr and hasKey, which Python does NOT!)

-- 
Take a recipe. Leave a recipe.  
Python Cookbook!  http://www.activestate.com/pythoncookbook